【静态分析】在springboot使用太阿（Tai-e）02

参考：使用太阿（Tai-e）进行静态代码安全分析（spring-boot篇二） - 先知社区

 本文章使用的被分析代码为GitHub - JoyChou93/java-sec-code: Java web common vulnerabilities and security code which is base on springboot and spring security

----------------------------------------------------------------------------------

1. 原理分析

1.1 控制反转

什么是控制反转？控制反转（IoC）是一种设计原则，其中应用程序的控制权被反转，由框架或容器负责管理对象的生命周期和控制对象之间的关系。这意味着应用程序不再负责直接实例化和管理对象，而是将这些任务委托给外部的框架或容器。
以如下代码为例：

@Configuration
public class AppConfig {

    @Bean
    public MyServiceImpl myService() {
        return new MyServiceImpl();
    }
}
@RestController
public class MovieRecommenderController {

    @Autowired
    private MyServiceImpl service;

    @GetMapping("/")
    public void doSomeAction(){
        service.action();
    }

    // ...
}

观察上面两段代码， 发现service的实例化和管理被Spring框架控制，而不是由应用程序直接控制。使用控制反转这样的技术可以使代码的对象的创建与使用解耦，降低组件之间的耦合度，使系统更易于维护、扩展和测试。而依赖注入是IoC的一种实现方式。它是指将一个对象的依赖关系通过构造函数、方法参数或属性注入到对象中，而不是在对象内部硬编码这些依赖关系。通过依赖注入，对象变得更加灵活和可配置。

1.2 指针分析如何处理函数调用？

在Tai-e，污点分析是作为指针分析的一个插件，在指针分析中完成了污点分析。所以在进一步分析控制反转前，我们需要先了解一下指针分析的基础。
指针分析就是计算指针（变量、字段）可以指向哪个对象的过程。指针分析首先需要对New语句进行分析，然后才能对assign、store、load语句进行分析，在此基础上进行指针分析传播，以及后续method call的处理。而对New语句初始化就需要用到堆抽象技术。

1.2.1 堆抽象

指针分析首先要进行堆抽象。对指针所代表的内存内容进行建模，Tai-e使用New Stmt创建一个新的对象(NewObj) 来实现堆抽象，即将指针所代表内容用对象构造时的Stmt代替。如下是构建一个堆抽象的案例。

A a = new A();
PT(a)={NewObj{<New: void main(java.lang.String[])>[0@L4] new A}}

这种堆抽象方法又叫做Allocation-Site abstraction，这是指针分析中最常见的堆抽象方法。

1.2.2 函数调用处理

在指针分析中会碰到许多函数调用，对象会沿着函数调用进行传播。在处理方法调用时时，需要分析出指针调用的具体方法。java的方法调用大概有以下四种，具体所调用方法的解析原理如下：

invokeinterface和invokevirtual
a.f(p1, p2)

当分析如上语句时，a.f所对应的函数就是指针a所对应Method即类A的方法。而在分析控制反转中，无法将service与其调用点关联起来，便无法分析出a.f实际所调用的函数
如上代码便是Tai-e中处理方法调用的相关代码：

private void processCall(CSVar recv, PointsToSet pts) {
    Context context = recv.getContext();
    Var var = recv.getVar();
    for (Invoke callSite : var.getInvokes()) {
        pts.forEach(recvObj -> {
            // resolve callee
            JMethod callee = CallGraphs.resolveCallee(
                    recvObj.getObject().getType(), callSite);
            if (callee != null) {
                // select context
                CSCallSite csCallSite = csManager.getCSCallSite(context, callSite);
                Context calleeContext = contextSelector.selectContext(
                        csCallSite, recvObj, callee);
                ......
                ......
            } else {
                plugin.onUnresolvedCall(recvObj, context, callSite);
            }
        });
    }
}

首先遍历pts（指针所指向堆抽象的集合），然后根据obj类型与当前函数调用callSite解析出具体调用的方法。

resolveCallee对应的源码如下，如果callSite所调用的方法为interface或者virtual，就会根据obj的类型与方法引用派生出具体的方法。

public static JMethod resolveCallee(Type type, Invoke callSite) {
    MethodRef methodRef = callSite.getMethodRef();
    if (callSite.isInterface() || callSite.isVirtual()) {
        return World.get().getClassHierarchy()
                .dispatch(type, methodRef);
    } else if (callSite.isSpecial()) {
        return World.get().getClassHierarchy()
                .dispatch(methodRef.getDeclaringClass(), methodRef);
    } else if (callSite.isStatic()) {
        return methodRef.resolveNullable();
    } else {
        throw new AnalysisException("Cannot resolve Invoke: " + callSite);
    }
}

dispatch会调用lookupMethod，其核心逻辑如下：

  1. 遍历超类，如果超类含有该方法，则返回超类中的该方法
  2. 遍历超类的所实现的所有接口，返回接口中的该方法
private JMethod lookupMethod(JClass jclass, Subsignature subsignature,
                             boolean allowAbstract) {
    // JVM Spec. (11 Ed.), 5.4.3.3 Method Resolution
    // 1. If C is an interface, method resolution throws
    // an IncompatibleClassChangeError. TODO: what does this mean???

    // 2. Otherwise, method resolution attempts to locate the
    // referenced method in C and its superclasses
    for (JClass c = jclass; c != null; c = c.getSuperClass()) {
        JMethod method = c.getDeclaredMethod(subsignature);
        if (method != null && (allowAbstract || !method.isAbstract())) {
            return method;
        }
    }
    // 3. Otherwise, method resolution attempts to locate the
    // referenced method in the superinterfaces of the specified class C
    for (JClass c = jclass; c != null; c = c.getSuperClass()) {
        for (JClass iface : c.getInterfaces()) {
            JMethod method = lookupMethodFromSuperinterfaces(
                    iface, subsignature, allowAbstract);
            if (method != null) {
                return method;
            }
        }
    }
    return null;
    // TODO:
    //  1. check accessibility
    //  2. handle phantom methods
    //  3. double-check correctness
}

2. 问题分析

在使用控制反转时，类的实例化是由spring的IoC容器控制，而不是应用程序自身控制。这使得在指针分析中，无法通过传统的dispatch获取到callsite具体调用的方法，而无法解析控制反转所控制的实例。
如果我们可以分析出当前对象所对应的具体实现类，那便可以在指针分析处理call调用时获取到具体的方法调用。
代码的具体实现如下：

solver.addPointsTo(solver.getCSManager().getCSVar(csMethod.getContext(), var),
                                        solver.getHeapModel().getMockObj(() -> "DEPENDENCY_INJECTION", cls.getName(), cls.getType()));

问题的关键就是如何找出当前被注入者所对应的具体实现类。

spring支持两种依赖注入的配置方式：

1. 通过注解配置

@Service
public class CustomizedService {
    @Resource
    private HttpService httpService;

    @GetMapping("/restTemplate/vuln1")
    public String RestTemplateUrlBanRedirects(String url){
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        return httpService.RequestHttpBanRedirects(url, headers);
    }
}
@Service
public class HttpServiceImpl implements HttpService {

        public String RequestHttpBanRedirects(String url, HttpHeaders headers) {
        HttpEntity<String> entity = new HttpEntity<>(headers);
        ResponseEntity<String> re = restTemplateBanRedirects.exchange(url, HttpMethod.GET, entity, String.class);
        return re.getBody();
    }
}

如上代码会将字段httpService的配置为HttpServiceImpl的实例，无需在CustomizedService.java添加构造httpService的代码。

2. 通过xml文件配置

package x.y;

public class ThingOne {

    public ThingOne(ThingTwo thingTwo, ThingThree thingThree) {
        // ...
    }
}
<beans>
  <bean id="beanOne" class="x.y.ThingOne">
    <constructor-arg ref="beanTwo"/>
    <constructor-arg ref="beanThree"/>
  </bean>

  <bean id="beanTwo" class="x.y.ThingTwo"/>

  <bean id="beanThree" class="x.y.ThingThree"/>
</beans>

通过如上配置，便可以将beanTwo、beanThree 自动配置为ThingOne构造参数，不需要在ThingOne中添加beanTwo、beanThree的构造过程。

3. 控制反转处理

如下为仓库GitHub - JoyChou93/java-sec-code: Java web common vulnerabilities and security code which is base on springboot and spring security中包含SSRF漏洞且利用了控制反转特性的代码片段

@RestController
@RequestMapping("/ssrf")
public class SSRF {

    private static final Logger logger = LoggerFactory.getLogger(SSRF.class);

    @Resource
    private HttpService httpService;

    @GetMapping("/restTemplate/vuln1")
    public String RestTemplateUrlBanRedirects(String url){
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        return httpService.RequestHttpBanRedirects(url, headers);
    }

    @GetMapping("/restTemplate/vuln2")
    public String RestTemplateUrl(String url){
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        return httpService.RequestHttp(url, headers);
    }

}

这个SSRF漏洞对应的调用链如下

org.joychou.controller.SSRF#RestTemplateUrlBanRedirects
org.joychou.impl.HttpServiceImpl#RequestHttpBanRedirects
org.springframework.web.client.RestTemplate#exchange

sink点的方法为org.springframework.web.client.RestTemplate#exchange，所以需要把该方法加入污点分析的配置文件。

另一个漏洞的sink点所调用方法与上个漏洞一致，不过调用链有所区别。

org.joychou.controller.SSRF#RestTemplateUrl
org.joychou.impl.HttpServiceImpl#RequestHttp
org.springframework.web.client.RestTemplate#exchange

4. 类CHA（Class Hierarchy Analysis）实现方式

根据原理分析一节中的描述，方法调用是通过堆抽象（用obj代表具体的类）所对应的类型解析出来的，当我们分析出当前指针所对应的实际类时，需要构造如下的MockObj，并将类型配置为我们解析出来的类型。

default Obj getMockObj(Descriptor desc, Object alloc, Type type) {
    return getMockObj(desc, alloc, type, null);
}
solver.addPointsTo(solver.getCSManager().getCSVar(csMethod.getContext(), var),
                                        solver.getHeapModel().getMockObj(() -> "DEPENDENCY_INJECTION", implementor.getName(), implementor.getType()));

实际代码如上，其中implementor为我们所分析出的具体的实现类。本质是将解析出的实际类所代表的MockObj添加至对应指针的指向集中。
具体实现思路如下：
遍历被分析代码中的所有方法，提取出Invoke语句即方法调用语句

具体实现思路如下：
遍历被分析代码中的所有方法，提取出Invoke语句即方法调用语句

solver.getCallGraph().reachableMethods().forEach(
    csMethod -> {
        if (csMethod.getMethod().getDeclaringClass().getName().matches("^(java\\.|sun\\.|javax\\.|com\\.sun\\.).+$")){
            return;
        }
        csMethod.getMethod().getIR().getStmts().forEach(
            stmt -> {
            }
    )
)

如果语句是静态方法调用或special调用，那不用分析

if(stmt instanceof Invoke invoke &&
        (invoke.isVirtual() || invoke.isInterface()) &&
        invoke.getRValue() instanceof InvokeInstanceExp invokeInstanceExp){
       //执行分析逻辑
}

如果接受者已经有了指向信息，代表接受者并不是由控制反转构造，不用分析

if(solver.getCSManager().getCSVar(context, var).getPointsToSet() != null &&
        !solver.getCSManager().getCSVar(context, var).getPointsToSet().isEmpty()) {
    return;
}

如果对象的类型为接口，那么可能的类就是所有实现类；
如果对象的类型为类，而非接口，那么可能的类就是所有子类。

JClass jClass = World.get().getClassHierarchy().getClass(var.getType().getName());
Collection<JClass> implementors = new ArrayList<>();
if(invoke.isInterface()){
    implementors.addAll(World.get().getClassHierarchy().getDirectImplementorsOf(jClass));
}else{
    implementors.add(jClass);
    implementors.addAll(World.get().getClassHierarchy().getDirectSubclassesOf(jClass));
}
System.out.printf("%s %s %s\n", var, jClass, implementors);

最后将可能的类加到对象的指向集中，指针分析会再分析方法调用，找到真实调用的方法

if(implementors.size() <= 3) {
    implementors.forEach(
        implementor -> {
            solver.addPointsTo(solver.getCSManager().getCSVar(csMethod.getContext(), var),
                    solver.getHeapModel().getMockObj(() -> "DEPENDENCY_INJECTION", implementor.getName(), implementor.getType()));
        }
    );
}

还有最后一个问题，对应的分析代码应该放在指针分析的哪个阶段？

根据DefaultSolver.javaanalyze方法的源码，指针分析会在完毕前调用onPhaseFinish，如果把代码放在此处，此时除控制反转外的其他分析都已经完成，会使我们的判断准确。

private void analyze() {
    while (!workList.isEmpty() && !isTimeout) {
        // phase starts
        while (!workList.isEmpty() && !isTimeout) {
            ......
            ......
        }
        plugin.onPhaseFinish();
    }
    if (!workList.isEmpty() && isTimeout) {
        logger.warn("Pointer analysis stops early as it reaches time limit ({} seconds)," +
                " and the result may be unsound!", timeLimit);
    } else if (timeLimiter != null) { // finish normally but time limiter is still running
        timeLimiter.stop();
    }
    plugin.onFinish();
}

完整代码如下

package pascal.taie.analysis.pta.plugin.taint;

import pascal.taie.World;
import pascal.taie.analysis.pta.core.cs.context.Context;
import pascal.taie.analysis.pta.core.solver.Solver;
import pascal.taie.analysis.pta.plugin.Plugin;
import pascal.taie.ir.exp.InvokeInstanceExp;
import pascal.taie.ir.exp.Var;
import pascal.taie.ir.stmt.Invoke;
import pascal.taie.language.classes.JClass;

import java.util.ArrayList;
import java.util.Collection;

public class DependencyInjectionHandler implements Plugin {
    private Solver solver;
    private boolean isCalled;

    public DependencyInjectionHandler(){
        isCalled = false;
    }

    @Override
    public void setSolver(Solver solver) {
        this.solver = solver;
    }

    @Override
    public void onPhaseFinish() {
        if(isCalled){
            return;
        }
        isCalled = true;
        solver.getCallGraph().reachableMethods().forEach(
            csMethod -> {
                if (csMethod.getMethod().getDeclaringClass().getName().matches("^(java\\.|sun\\.|javax\\.|com\\.sun\\.).+$")){
                    return;
                }
                csMethod.getMethod().getIR().getStmts().forEach(
                    stmt -> {
                        if(stmt instanceof Invoke invoke &&
                                (invoke.isVirtual() || invoke.isInterface()) &&
                                invoke.getRValue() instanceof InvokeInstanceExp invokeInstanceExp){
                            Var var = invokeInstanceExp.getBase();
                            Context context = csMethod.getContext();
                            if(solver.getCSManager().getCSVar(context, var).getPointsToSet() != null &&
                                    !solver.getCSManager().getCSVar(context, var).getPointsToSet().isEmpty()) {
                                return;
                            }
                            JClass jClass = World.get().getClassHierarchy().getClass(var.getType().getName());
                            Collection<JClass> implementors = new ArrayList<>();
                            if(invoke.isInterface()){
                                implementors.addAll(World.get().getClassHierarchy().getDirectImplementorsOf(jClass));
                            }else{
                                implementors.add(jClass);
                                implementors.addAll(World.get().getClassHierarchy().getDirectSubclassesOf(jClass));
                            }
                            if(invoke.toString().contains("RequestHttp")){
                                System.out.printf("%s %s %s\n", var, jClass, implementors);
                            }
                            if(implementors.size() <= 3) {
                                implementors.forEach(
                                    implementor -> {
                                        solver.addPointsTo(solver.getCSManager().getCSVar(csMethod.getContext(), var),
                                                solver.getHeapModel().getMockObj(() -> "DEPENDENCY_INJECTION", implementor.getName(), implementor.getType()));
                                    }
                                );
                            }
                        }
                    });
            });
    }
}

该方法可以扫描出依赖于控制反转的漏洞，但是上述方式缺乏准确性，如果一个接口有多个实现类，就无法准确识别出该指针所对应的实现类。

5. 基于注解的配置解析

在代码中，控制反转是通过xml、注解进行实际配置。因此通过解析xml、注解的实际含义，会使结果更加准确。

本文只分析基于注解的配置解析。
实现思路为识别注入点以及依赖实现类，然后将依赖实现类构造成的obj添加到注入点变量的的指向集中。

对于如下代码而言，需要识别出CustomizedService的注入点httpService，然后找到HttpService的实现类，最后把实现类HttpServiceImpl以obj的形式添加到变量的指向集中。

@Service
public class CustomizedService {
    @Resource
    private HttpService httpService;

    @GetMapping("/restTemplate/vuln1")
    public String RestTemplateUrlBanRedirects(String url){
        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);
        return httpService.RequestHttpBanRedirects(url, headers);
    }
}
@Service
public class HttpServiceImpl implements HttpService {

        public String RequestHttpBanRedirects(String url, HttpHeaders headers) {
        HttpEntity<String> entity = new HttpEntity<>(headers);
        ResponseEntity<String> re = restTemplateBanRedirects.exchange(url, HttpMethod.GET, entity, String.class);
        return re.getBody();
    }
}

实现方法如下：

5.1 注入点识别

List<JField> injectedFields = new ArrayList<>();
World.get().getClassHierarchy().allClasses()
        .map(JClass::getDeclaredFields)
        .flatMap(Collection::stream)
        .forEach(field -> {
            boolean isInjectedField = field.hasAnnotation("javax.annotation.Resource") ||
                    field.hasAnnotation("org.springframework.beans.factory.annotation.Autowired") ||
                    field.hasAnnotation("javax.inject.Inject");
            if(isInjectedField){
                injectedFields.add(field);
            }
        });

遍历所有类的所有字段，若字段包含以下注解，则说明该字段是注入点

  • javax.annotation.Resource
  • org.springframework.beans.factory.annotation.Autowired
  • javax.inject.Inject

5.2 寻找实现类

List<JClass> implementationClasses = new ArrayList<>();
implementationClasses.addAll(
    World.get().getClassHierarchy().allClasses()
            .filter(cls -> cls.hasAnnotation("org.springframework.stereotype.Service") ||
                    cls.hasAnnotation("org.springframework.stereotype.Component")).collect(Collectors.toSet())
);

遍历所有类，若类包含以下注解，则说明该类为实现类

  • org.springframework.stereotype.Service
  • org.springframework.stereotype.Component

5.3 将实现类与注入点关联起来

如果在方法中要使用当前类的字段，会从%this变量中载入该字段，然后使用。
[4@L281] $r4 = %this.<org.joychou.controller.SSRF: org.joychou.service.HttpService httpService>;

@org.springframework.web.bind.annotation.GetMapping({"/restTemplate/vuln1"})
public java.lang.String RestTemplateUrlBanRedirects(java.lang.String url) {
    org.springframework.http.HttpHeaders $r0;
    org.springframework.http.MediaType $r1;
    org.joychou.service.HttpService $r4;
    java.lang.String $r5;
    [0@L279] $r0 = new org.springframework.http.HttpHeaders;
    [1@L279] invokespecial $r0.<org.springframework.http.HttpHeaders: void <init>()>();
    [2@L280] $r1 = <org.springframework.http.MediaType: org.springframework.http.MediaType APPLICATION_JSON_UTF8>;
    [3@L280] invokevirtual $r0.<org.springframework.http.HttpHeaders: void setContentType(org.springframework.http.MediaType)>($r1);
    [4@L281] $r4 = %this.<org.joychou.controller.SSRF: org.joychou.service.HttpService httpService>;
    [5@L281] $r5 = invokeinterface $r4.<org.joychou.service.HttpService: java.lang.String RequestHttpBanRedirects(java.lang.String,org.springframework.http.HttpHeaders)>(url, $r0);
    [6@L281] return $r5;
}

如果要将实现类与注入点关联起来，就相当于把实现类与LoadField的返回值关联起来。具体关联代码如下：

injectedFields.stream().forEach(field -> {
    JClass jClass = field.getDeclaringClass();

    Collection<JClass> subClasses = World.get().getClassHierarchy().getAllSubclassesOf(
            World.get().getClassHierarchy().getClass(field.getType().getName())
    );
    List<JClass> implementors = new ArrayList<>(subClasses);
    implementors.retainAll(implementationClasses);
    System.out.printf("%s %s\n", field, implementors);

    Set<CSMethod> csMethodSet = solver.getCallGraph().reachableMethods()
            .filter(csMethod -> csMethod.getMethod().getDeclaringClass().equals(jClass))
            .collect(Collectors.toSet());
    csMethodSet.forEach(
            csMethod -> {
                List<Var> vars = csMethod.getMethod().getIR().getStmts().stream()
                        .filter(stmt -> stmt instanceof LoadField loadField &&
                                loadField.getFieldAccess().getFieldRef().resolve().equals(field))
                        .map(stmt -> (LoadField) stmt)
                        .map(AssignStmt::getLValue)
                        .toList();
                implementors.forEach(
                        implementor -> {
                            vars.forEach(
                                    var -> {
                                        solver.addPointsTo(solver.getCSManager().getCSVar(csMethod.getContext(), var),
                                                solver.getHeapModel().getMockObj(() -> "DEPENDENCY_INJECTION", implementor.getName(), implementor.getType()));
                                    }
                            );
                        }
                );
            }
    );
});
  1. 获取注入点字段的所属类，然后获取该类中所有上下文有关的方法；
  2. 获取字段类型的所有子类，如果是接口，则获取所有实现类。与之前所有的实现类取交集，这个交集就是控制反转中该字段的实现类；
  3. 遍历第一步获取到的方法的所有语句，若语句的类型是LoadField，则判断其FieldAccess的字段是否为注入点的字段，若是，则用第二步的实现类构造MockObj，将其添加到LoadField语句的返回值的指向集中。

6. 结果展示

lcark、keanu两位大佬更改的相关代码以及配置文件已经上传至github
具体食用方法如下：

 

1. 下载代码，并移动至spring-boot-2目录下

    git clone https://github.com/lcark/Tai-e-demo
    cd Tai-e-demo/spring-boot-2
    git submodule update --init

2. 将java-sec-code文件夹移至与Tai-e-demo文件夹相同目录下

3. 将DependencyInjectionHandler.java移动至Tai-e源码的src/main/java/pascal/taie/analysis/pta/plugin/taint/目录下，并重新编译打包

4. 使用如下命令运行tai-e便可以成功获取到扫描结果

java -cp xxx\tai-e-all-0.5.1-SNAPSHOT.jar pascal.taie.Main --options-file=options.yml

5. 如下图所示，两个测试案例都被检测到

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/654995.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

【Linux】Linux基本指令1

【Linux】Linux基本指令1

1.软件&#xff0c;OS&#xff0c;驱动 我们看看计算机的结构层次 1.1.操作系统 操作系统是一款做 软硬件管理 的软件 操作系统&#xff08;计算机管理控制程序&#xff09;_百度百科 (baidu.com) 操作系统&#xff08;英语&#xff1a;Operating System&#xff0c;缩写&a…
阅读更多...
做视频号小店遇到差评怎么处理？如何规避差

做视频号小店遇到差评怎么处理？如何规避差

大家好&#xff0c;我是喷火龙。 大家在做店的时候应该都会遇到品退、中差评这些问题&#xff0c;这对我们的店铺影响还是非常大的&#xff0c;差评过多就会影响店铺的体验分&#xff0c;从而影响店铺的流量&#xff0c;还会间接的影响商品的转化率&#xff0c;如果太低的话&a…
阅读更多...
nginx的常用配置与命令相关硬核干货

nginx的常用配置与命令相关硬核干货

今天小晨跟大家分享Nginx常用配置与命令相关的硬核干货&#xff0c;可以说运维工作中基本都会用到这些&#xff0c;掌握它&#xff0c;你可以不用求人&#xff01; Nginx特点 高并发、高性能&#xff1b; 模块化架构使得它的扩展性非常好&#xff1b; 异步非阻塞的事件驱动模…
阅读更多...
如何使用java设计出一款可以玩的数独游戏！

如何使用java设计出一款可以玩的数独游戏！

要用Java设计一个数独游戏，你可以按照以下步骤进行： 创建一个9x9的二维数组来表示数独的棋盘。生成一个有效的数独解作为游戏的答案。随机地从答案中移除一些数字，以创建游戏的难度等级。创建一个图形用户界面（GUI）来显示棋盘和与用户的交互。检测用户输入的数字是否正确，…
阅读更多...
流水账（CPU设计实战）——lab3

流水账（CPU设计实战）——lab3

Lab3 Rewrite V1.0 版本控制 版本描述V0V1.0相对V0变化&#xff1a; 修改了文件名&#xff0c;各阶段以_stage结尾&#xff08;因为if是关键词&#xff0c;所以module名不能叫if&#xff0c;遂改为if_stage&#xff0c;为了统一命名&#xff0c;将所有module后缀加上_stage&a…
阅读更多...
设计模式 22 访问者模式 Visitor Pattern

设计模式 22 访问者模式 Visitor Pattern

设计模式 22 访问者模式 Visitor Pattern 1.定义 访问者模式是一种行为型设计模式&#xff0c;它允许你在不改变已有类结构的情况下&#xff0c;为一组对象添加新的操作。它将算法与对象结构分离&#xff0c;使你能够在不修改现有类的情况下&#xff0c;为这些类添加新的操作。…
阅读更多...
Autosar Dcm配置-特定NRC实现方式-基于ETAS软件

Autosar Dcm配置-特定NRC实现方式-基于ETAS软件

文章目录 前言工具配置代码编写总结 前言 项目开发过程中&#xff0c;诊断服务一般客户需求或系统需求都会有特定NRC(一般为NRC22-条件不满足)&#xff0c;也就会有特定的条件&#xff0c;需要手动加代码实现。本文介绍ETAS工具中配置的接口及简单实现。 工具配置 对于每一个…
阅读更多...
【高阶数据结构】 B树 -- 详解

【高阶数据结构】 B树 -- 详解

一、常见的搜索结构 适合做内查找&#xff1a; 以上结构适合用于数据量相对不是很大&#xff0c;能够一次性存放在内存中&#xff0c;进行数据查找的场景。如果数据量很大&#xff0c;比如有 100G 数据&#xff0c;无法一次放进内存中&#xff0c;那就只能放在磁盘上了。 如果…
阅读更多...
坦克飞机大战项目详解：从包结构到测试发布

坦克飞机大战项目详解：从包结构到测试发布

新书上架~&#x1f447;全国包邮奥~ python实用小工具开发教程http://pythontoolsteach.com/3 欢迎关注我&#x1f446;&#xff0c;收藏下次不迷路┗|&#xff40;O′|┛ 嗷~~ 目录 一、项目初始化与包结构构建 代码案例&#xff1a; 二、资源文件与配置文件管理 代码案例…
阅读更多...
关于NLTK

关于NLTK

一、NLTK简介 下图来自NLTK官网&#xff1a;https://www.nltk.org/index.html NLTK&#xff0c;全称为Natural Language Toolkit&#xff0c;是一个用于处理和分析自然语言文本的Python库。它提供了一系列丰富的工具和资源&#xff0c;包括词汇资源&#xff08;如WordNet&am…
阅读更多...
【接口自动化_05课_Pytest接口自动化简单封装与Logging应用】

【接口自动化_05课_Pytest接口自动化简单封装与Logging应用】

一、关键字驱动--设计框架的常用的思路 封装的作用&#xff1a;在编程中&#xff0c;封装一个方法&#xff08;函数&#xff09;主要有以下几个作用&#xff1a;1. **代码重用**&#xff1a;通过封装重复使用的代码到一个方法中&#xff0c;你可以在多个地方调用这个方法而不是…
阅读更多...
【进程空间】通过页表寻址的过程

【进程空间】通过页表寻址的过程

文章目录 前言介绍页表、页框、页目录的概念页框页表页目录页表和页目录的分配 一级页表和二级页表一级页表寻址过程 二级页表寻址过程 一级页表和二级页表的对比 前言 我们知道每个进程都有属于自己的虚拟地址空间&#xff0c;且每个进程的虚拟地址都是统一的。要想通过虚拟地…
阅读更多...
JS逆向之企名科技

JS逆向之企名科技

文章目录 初步分析定位js编写完整代码参考文献初步分析 目标网址：企名科技 抓包分析，发现是post请求 请求代码如下： #!/usr/bin/env python3 # -*- coding: utf-8 -*- import requestsheaders = {Connection:
阅读更多...
【主流分布式算法总结】

【主流分布式算法总结】

文章目录 分布式常见的问题常见的分布式算法Raft算法概念Raft的实现 ZAB算法Paxos算法 分布式常见的问题 分布式场景下困扰我们的3个核心问题&#xff08;CAP&#xff09;&#xff1a;一致性、可用性、分区容错性。 1、一致性&#xff08;Consistency&#xff09;&#xff1a;…
阅读更多...
玄机平台应急响应—webshell查杀

玄机平台应急响应—webshell查杀

1、前言 这篇文章说一下应急响应的内容&#xff0c;webshell查杀呢是应急响应的一部分。那么什么是应急响应呢&#xff0c;所谓的应急响应指的是&#xff0c;当网站突然出现异常情况或者漏洞时&#xff0c;能够马上根据实际问题进行分析&#xff0c;然后及时解决问题。 2、应…
阅读更多...
内网安全-隧道搭建穿透上线内网穿透-nps自定义上线内网渗透-Linux上线-cs上线Linux主机

内网安全-隧道搭建穿透上线内网穿透-nps自定义上线内网渗透-Linux上线-cs上线Linux主机

目录 内网安全-隧道搭建&穿透上线内网穿透-nps-自定义-上线NPS工具介绍搭建过程 nps原理介绍MSF上线CS上线 内网渗透-Linux上线-cs上线Linux主机1.下载插件2.导入插件模块3.配置监听器4.服务端配置5.配置C2监听器并生成木马6.执行木马 内网安全-隧道搭建&穿透上线 内网…
阅读更多...
做抖店如何避免被同行内卷？这5点建议，可以解决这个问题

做抖店如何避免被同行内卷？这5点建议，可以解决这个问题

我是王路飞。 都说2024年的抖店不赚钱了&#xff0c;商家太多了&#xff0c;太内卷了&#xff0c;一点都不好做~ 那为什么依然有很多商家在坚持做呢&#xff1f;为什么依然有很多新手入局呢&#xff1f; 无非是抖店确实能带来可观的利润回报罢了。 那如何避免被同行内卷呢&…
阅读更多...
idea中git检出失败

idea中git检出失败

之前clone好好的&#xff0c;今天突然就拉取不下来了。很多时候是用户凭证的信息没更新的问题。由于window对同一个地址都存储了会话。如果是新的会话&#xff0c;必须要更新window下的凭证。 然后根据你的仓库找到你对应的账户&#xff0c;更新信息即可。
阅读更多...
【前端】从手动部署到自动部署：前端项目进化之路

【前端】从手动部署到自动部署：前端项目进化之路

从手动部署到自动部署&#xff1a;前端项目进化之路 在前端开发的领域内&#xff0c;部署是一个不可忽视的环节。随着项目复杂度的增加和线上更新频率的提升&#xff0c;手动部署逐渐暴露出它的弊端。本文将带你从手动部署过渡到自动部署&#xff0c;完成前端项目进化的重要一…
阅读更多...
Round-Robin 调度逻辑算法

Round-Robin 调度逻辑算法

Round-Robin 调度逻辑算法 1 Intro1.1 固定优先级1.2 Round-Robin算法 之前上学还是工作&#xff0c;都接触过调度算法&#xff1a;Round-Robin和weight-Round Robin算法&#xff0c;但只知道它的功能和目的是什么&#xff0c;没有具体了解如何实现的&#xff1b; 现在是工作上…
阅读更多...
最新文章

Copyright @ 2022~2023