2024-08-23



package main
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)
 
// 自定义中间件
func MyMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        fmt.Println("中间件开始执行")
        // 在这里可以进行一些预处理操作
        // 调用下一个中间件或控制器
        c.Next()
        // 在这里可以进行一些后处理操作
        fmt.Println("中间件执行结束")
    }
}
 
// 自定义控制器
func CustomController(c *gin.Context) {
    name := c.Query("name")
    c.String(http.StatusOK, "Hello %s", name)
}
 
func main() {
    router := gin.Default() // 创建一个带有默认中间件的路由引擎
 
    // 使用自定义中间件
    router.Use(MyMiddleware())
 
    // 创建一个基本路由
    router.GET("/hello", CustomController)
 
    // 启动服务器
    router.Run(":8080")
}

这段代码定义了一个自定义的中间件MyMiddleware和一个自定义的控制器CustomController。在main函数中,我们创建了一个带有默认中间件的Gin路由引擎,并使用Use方法加入了自定义的中间件。然后,我们定义了一个基本的GET路由,并将自定义控制器绑定到该路由上。最后,我们启动服务器,监听8080端口的请求。

2024-08-23



package main
 
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
 
// 局部中间件,仅应用于特定路由
func localMiddleware(c *gin.Context) {
    // 在调用下游处理器之前执行的逻辑
    c.Writer.Header().Set("X-Local-Middleware", "true")
    c.Next() // 调用下一个中间件或路由处理器
    // 在调用下游处理器之后执行的逻辑
}
 
// 全局中间件,应用于所有路由
func globalMiddleware(c *gin.Context) {
    // 在调用下游处理器之前执行的逻辑
    c.Writer.Header().Set("X-Global-Middleware", "true")
    c.Next() // 调用下一个中间件或路由处理器
    // 在调用下游处理器之后执行的逻辑
}
 
func main() {
    router := gin.Default() // 创建一个带有默认中间件的路由器
 
    // 全局注册中间件
    router.Use(globalMiddleware)
 
    // 创建一个分支路由,并注册局部中间件
    api := router.Group("/api")
    api.Use(localMiddleware)
    {
        api.GET("/hello", func(c *gin.Context) {
            c.String(http.StatusOK, "Hello from API")
        })
    }
 
    // 启动服务器
    router.Run(":8080")
}

这段代码演示了如何在Gin框架中定义和使用局部和全局中间件。首先定义了两个中间件函数localMiddlewareglobalMiddleware。然后在路由器中全局注册了globalMiddleware,并在特定分支路由上注册了localMiddleware。最后,在:8080端口启动了服务器。

2024-08-23

以下是安装和启动Redis、Nginx、Nacos以及Kafka的基本命令和步骤。请根据您的操作系统和环境选择合适的安装方式。

  1. Redis:

    安装:

    
    
    
    # 使用包管理器安装Redis
    sudo apt-get install redis-server

    启动:

    
    
    
    # 启动Redis服务
    redis-server
  2. Nginx:

    安装:

    
    
    
    # 使用包管理器安装Nginx
    sudo apt-get install nginx

    启动:

    
    
    
    # 启动Nginx服务
    sudo systemctl start nginx
    # 设置Nginx开机自启
    sudo systemctl enable nginx
  3. Nacos:

    安装:

    • 从官网下载Nacos的压缩包并解压。
    • 或者使用Maven命令下载Nacos并启动:

      
      
      
      mvn -U clean package -Dmaven.test.skip=true

    启动:

    • 进入Nacos的bin目录,使用以下命令启动Nacos:

      
      
      
      ./startup.sh -m standalone
  4. Kafka:

    安装:

    • 下载Kafka的压缩包并解压。
    • 使用包管理器安装Java,因为Kafka是用Java编写的。

    启动:

    • 进入Kafka的config目录,编辑server.properties文件,设置Zookeeper的地址。
    • 进入Kafka的bin目录,启动Kafka服务:

      
      
      
      ./kafka-server-start.sh -daemon ../config/server.properties

请注意,以上命令可能需要根据您的操作系统和环境进行调整。对于Windows系统,您可能需要从官方网站下载可执行文件或使用WSL来运行Linux命令。对于生产环境,您可能需要配置更多的参数和设置,并考虑安全性和性能等问题。

2024-08-23



package main
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)
 
func main() {
    router := gin.Default() // 创建一个带有默认中间件的路由器
 
    // 定义一个全局的404处理器
    router.NoRoute(func(c *gin.Context) {
        c.String(http.StatusNotFound, "404 NOT FOUND: %s", c.Request.URL.Path)
    })
 
    // 文件上传的处理器
    router.POST("/upload", func(c *gin.Context) {
        // 假设这里有文件上传的处理逻辑
        // 例如:c.SaveUploadedFile(c.Request.FormFile("upload"), "./uploads")
        c.String(http.StatusOK, "文件上传成功")
    })
 
    // 启动服务器
    router.Run(":8080")
}
 
// 自定义中间件示例
func MyMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 在这里可以进行一些请求处理前的逻辑
        fmt.Println("中间件处理前")
 
        // 调用下一个中间件或处理器
        c.Next()
 
        // 在这里可以进行一些响应处理后的逻辑
        fmt.Println("中间件处理后")
    }
}

这个示例代码展示了如何在Gin框架中创建一个带有默认中间件的路由器,并设置了一个全局的404处理器。同时,展示了如何实现一个简单的文件上传处理器,以及如何创建和使用一个自定义的中间件。

2024-08-23



package main
 
import (
    "fmt"
    "log"
    "net/http"
 
    "github.com/gin-gonic/gin"
)
 
func main() {
    router := gin.Default() // 创建一个带有默认中间件的路由器
 
    // 设置一个简单的 GET 路由
    router.GET("/hello", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello, World!")
    })
 
    // 启动服务器
    if err := router.Run(":8080"); err != nil {
        log.Fatal(err)
    }
}
 
// 打印请求和回包内容的函数
func logMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 请求日志:请求方法、URL、IP
        start := time.Now()
        c.Next() // 处理请求
        end := time.Now()
 
        log.Printf("[%s] %s %s - %v\n",
            c.Request.Method,
            c.Request.RequestURI,
            c.ClientIP(),
            end.Sub(start),
        )
 
        // 响应日志:状态码、响应时间、Body
        log.Printf("Response Body: %s", c.Writer.Body)
    }
}

这个示例代码展示了如何使用Gin框架创建一个简单的Web服务器,并使用自定义的日志中间件来优雅地打印请求和响应内容。这对于开发者了解HTTP请求和响应的详细信息非常有帮助,也可以作为开发中的调试工具。

2024-08-23

在Golang的Gin框架中,Next()函数是中间件中的一个关键概念。Next()函数的主要目的是执行下一个中间件或路由处理器。如果你想在执行Next()之前或之后传递值,你可以使用context对象来实现。

以下是一个示例,展示了如何在Gin中使用Next()函数以及如何传递值:




package main
 
import (
    "github.com/gin-gonic/gin"
    "net/http"
)
 
func main() {
    r := gin.Default()
 
    // 中间件1
    r.Use(func(c *gin.Context) {
        c.Set("request_id", "12345")
        println("中间件1: 设置了request_id")
        c.Next()
        println("中间件1: 继续执行后续操作")
    })
 
    // 中间件2
    r.Use(func(c *gin.Context) {
        requestID := c.MustGet("request_id").(string)
        println("中间件2: 获取到的request_id是", requestID)
        c.Next()
    })
 
    // 路由处理器
    r.GET("/", func(c *gin.Context) {
        requestID := c.MustGet("request_id").(string)
        println("路由处理器: 获取到的request_id是", requestID)
        c.String(http.StatusOK, "Hello, World!")
    })
 
    r.Run()
}

在这个示例中,我们定义了两个中间件和一个路由处理器。在第一个中间件中,我们使用c.Set()方法设置了一个键值对,然后调用c.Next()执行下一个中间件或路由处理器。在第二个中间件中,我们通过c.MustGet()获取了之前设置的值,并打印了出来。在路由处理器中,我们同样通过c.MustGet()获取了之前设置的值,并在执行完成后返回了响应。

在实际应用中,你可以通过这种方式在中间件之间传递值,并确保在Next()被调用之后继续执行后续的逻辑。

2024-08-23

由于Nginx中间件的具体漏洞类型和版本未知,我无法提供针对特定漏洞的复现代码。然而,我可以提供一个通用的Nginx配置和漏洞利用的示例。

  1. 安装Nginx:



sudo apt-update
sudo apt install nginx
  1. 配置Nginx(示例配置,根据实际情况修改):



server {
    listen 80;
    server_name localhost;
 
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
    }
 
    # 其他配置...
}
  1. 保存配置并重启Nginx:



sudo nginx -t
sudo systemctl restart nginx
  1. 漏洞利用(示例,根据实际漏洞修改):

    如果存在文件解析漏洞,攻击者可以尝试通过构造特定的请求利用此漏洞。例如,如果Nginx配置中包含类似以下配置:




location ~* \.(php|jsp|asp)$ {
    root /usr/share/nginx/html;
    index index.html index.htm;
}

攻击者可以尝试请求一个不存在的PHP或JSP文件,如果Nginx处理这些文件请求,可能会导致文件解析漏洞。




curl http://your-server-ip/.php.txt

请注意,上述步骤和示例仅用于说明如何复现漏洞。实际的漏洞复现取决于具体的漏洞类型和Nginx的版本。如果你需要复现具体的Nginx漏洞,请提供详细的漏洞信息,包括漏洞类型、版本和配置细节。

2024-08-23

在Gin框架中,自定义中间件是一种很常见的功能。中间件可以拦截HTTP请求,并在请求处理之前和之后执行一些特定的操作。

以下是一个简单的Gin自定义中间件的例子:




package main
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
)
 
// 自定义中间件
func MyMiddleware() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 在处理请求之前执行的代码
        fmt.Println("Before request")
 
        // 继续执行其他的中间件或处理请求
        c.Next()
 
        // 在处理请求之后执行的代码
        fmt.Println("After request")
    }
}
 
func main() {
    r := gin.Default()
 
    // 使用自定义中间件
    r.Use(MyMiddleware())
 
    // 一个测试的API路由
    r.GET("/test", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello from test endpoint!")
    })
 
    // 启动服务器
    r.Run()
}

在这个例子中,我们定义了一个名为MyMiddleware的中间件,它打印出了请求的处理前后的消息。然后,我们通过调用r.Use(MyMiddleware())将其应用到了Gin的路由器上。在中间件内部,我们使用c.Next()来调用链中的下一个中间件或处理器。

运行这段代码后,访问/test路径,你会看到在请求处理前后,控制台分别打印了相关的日志信息。

2024-08-23

在Gin框架中,我们可以使用中间件来记录操作日志。以下是一个简单的示例,展示了如何创建一个记录操作日志的中间件,并将其添加到Gin路由器中:




package main
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "log"
    "time"
)
 
// 自定义日志中间件
func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        // 开始时间
        startTime := time.Now()
 
        // 处理请求
        c.Next()
 
        // 结束时间
        endTime := time.Now()
 
        // 日志格式
        log.Printf("[%s] %s %s %s %v\n",
            endTime.Format("2006/01/02 - 15:04:05"),
            c.Request.Method,
            c.Request.RequestURI,
            c.ClientIP(),
            endTime.Sub(startTime),
        )
    }
}
 
func main() {
    router := gin.Default()
 
    // 添加日志中间件
    router.Use(Logger())
 
    router.GET("/", func(c *gin.Context) {
        c.String(200, "Hello, World!")
    })
 
    // 运行服务器
    port := "8080"
    if err := router.Run(":" + port); err != nil {
        fmt.Printf("服务器启动失败:%v\n", err)
    }
}

在这个示例中,我们定义了一个名为Logger的中间件函数,它记录每个请求的开始和结束时间,并计算处理请求所需的时间。然后,我们通过调用router.Use(Logger())将其添加到Gin路由器中。每当有请求进入时,都会先通过这个中间件,然后记录相关的日志信息。

2024-08-23

在第59天的学习中,我们将重点关注服务器安全性,特别是中间件安全性,了解如何复现已知的安全漏洞,比如CVE(Common Vulnerabilities & Exposures)。我们还将关注IIS、Apache、Tomcat和Nginx等服务器中间件的安全性和配置。

以下是一些可能的学习内容和示例代码:

  1. 了解CVE漏洞的原理和影响。
  2. 学习如何安装和配置IIS、Apache、Tomcat和Nginx等服务器中间件。
  3. 复现CVE漏洞,比如对IIS的MS17-010、Apache的Apache Shiro反序列化漏洞等。
  4. 通过安全工具检测中间件的安全性,如对IIS的IIS Scanner等。
  5. 了解中间件安全配置最佳实践,比如防止目录遍历、使用安全的配置文件等。

示例代码:




# 安装IIS
sudo apt-get install iis
 
# 安装Apache
sudo apt-get install apache2
 
# 安装Tomcat
wget https://downloads.apache.org/tomcat/tomcat-9/v9.0.62/bin/apache-tomcat-9.0.62.tar.gz
tar xzvf apache-tomcat-9.0.62.tar.gz
mv apache-tomcat-9.0.62 /usr/local/tomcat9
 
# 安装Nginx
sudo apt-get install nginx
 
# 复现CVE漏洞,例如MS17-010对于IIS
# 需要具体的复现步骤和环境配置

请注意,实际的漏洞复现可能需要特定的环境和步骤,而且在实际的渗透测试中应该遵守法律法规,不进行破坏性操作。