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请求和响应的详细信息非常有帮助，也可以作为开发中的调试工具。

在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()被调用之后继续执行后续的逻辑。

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

1. 安装Nginx：

sudo apt-update
sudo apt install nginx

2. 配置Nginx（示例配置，根据实际情况修改）：

server {
    listen 80;
    server_name localhost;
 
    location / {
        root /usr/share/nginx/html;
        index index.html index.htm;
    }
 
    # 其他配置...
}

3. 保存配置并重启Nginx：

sudo nginx -t
sudo systemctl restart nginx

4. 漏洞利用（示例，根据实际漏洞修改）：

   如果存在文件解析漏洞，攻击者可以尝试通过构造特定的请求利用此漏洞。例如，如果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漏洞，请提供详细的漏洞信息，包括漏洞类型、版本和配置细节。

在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路径，你会看到在请求处理前后，控制台分别打印了相关的日志信息。

在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路由器中。每当有请求进入时，都会先通过这个中间件，然后记录相关的日志信息。

在第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
# 需要具体的复现步骤和环境配置

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

package main
 
import (
    "fmt"
    "github.com/gin-gonic/gin"
    "net/http"
    "time"
)
 
// 自定义日志格式
type customLogger struct {
    method string
    url    string
    status int
    start  time.Time
}
 
// 实现 gin.HandlerFunc 接口
func (c *customLogger) Write(p []byte) (n int, err error) {
    fmt.Printf("[%s] %q %d %v\n", c.method, c.url, c.status, time.Since(c.start))
    return len(p), nil
}
 
// Logger 中间件
func Logger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        path := c.Request.URL.Path
        logger := &customLogger{
            method: c.Request.Method,
            url:    path,
            start:  start,
        }
        // 重写 ResponseWriter 的 Write 方法
        c.Writer = logger
 
        // 继续执行其他的中间件和处理函数
        c.Next()
 
        // 当所有中间件和处理函数执行完毕后，记录响应状态码
        logger.status = c.Writer.Status()
    }
}
 
func main() {
    r := gin.Default()
 
    // 使用自定义的Logger中间件
    r.Use(Logger())
 
    r.GET("/", func(c *gin.Context) {
        c.String(http.StatusOK, "Hello World!")
    })
 
    // 启动服务器
    r.Run(":8080")
}

这段代码定义了一个自定义的日志中间件Logger，它会记录每个请求的HTTP方法、URL、响应时间和状态码。在main函数中，我们使用r.Use(Logger())来应用这个中间件。当服务器接收到请求时，Logger中间件会记录请求的开始时间，并在请求处理完毕后记录状态码和响应时间。

Nginx是一个高性能的HTTP和反向代理服务器，也是一个IMAP/POP3/SMTP服务器。以下是一些常见的Linux中间件Nginx的使用场景和示例代码：

1. 作为静态内容的Web服务器：

server {
    listen       80;
    server_name  localhost;
 
    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }
}

2. 作为代理服务器：

server {
    listen       80;
    server_name  localhost;
 
    location / {
        proxy_pass http://upstream_server;
    }
}

3. 配置负载均衡：

upstream backend {
    server backend1.example.com;
    server backend2.example.com;
}
 
server {
    listen       80;
    server_name  localhost;
 
    location / {
        proxy_pass http://backend;
    }
}

4. 配置SSL/TLS：

server {
    listen       443 ssl;
    server_name  localhost;
 
    ssl_certificate      /etc/nginx/ssl/nginx.crt;
    ssl_certificate_key  /etc/nginx/ssl/nginx.key;
 
    location / {
        root   /usr/share/nginx/html;
        index  index.html index.htm;
    }
}

5. 配置缓存：

server {
    listen       80;
    server_name  localhost;
 
    location / {
        proxy_pass http://backend;
        proxy_cache my_cache;
        proxy_cache_valid 200 1d;
    }
}

6. 配置负载压力测试：

server {
    listen       80;
    server_name  localhost;
 
    location / {
        proxy_pass http://backend;
        proxy_connect_timeout 1s;
        proxy_read_timeout 1s;
    }
}

7. 配置日志记录：

server {
    listen       80;
    server_name  localhost;
 
    location / {
        proxy_pass http://backend;
        access_log  /var/log/nginx/access.log;
        error_log   /var/log/nginx/error.log;
    }
}

这些示例仅展示了Nginx配置的一部分，实际配置需要根据具体需求进行调整。

# 使用外部Nginx基础镜像
FROM nginx:1.19.0
 
# 定义数据目录
ENV NGINX_DIR /etc/nginx
ENV NGINX_LOG_DIR /var/log/nginx
ENV NGINX_HTML_DIR /usr/share/nginx/html
 
# 创建配置文件目录
RUN mkdir -p ${NGINX_DIR}/conf.d
 
# 复制自定义配置文件
COPY custom.conf ${NGINX_DIR}/conf.d/default.conf
 
# 复制静态文件
COPY html/* ${NGINX_HTML_DIR}
 
# 设置容器启动时执行的命令
CMD ["nginx", "-g", "daemon off;"]

这个Dockerfile示例展示了如何使用外部的Nginx基础镜像，并覆盖默认配置文件以及复制自定义的静态文件。这样做避免了重复编写Nginx的安装和配置过程，同时也使得镜像的维护更加简单和高效。

Nginx中间件漏洞复现通常涉及到CVE-2019-9193漏洞，该漏洞是因为Nginx在处理包含特制的If-Modified-Since头的请求时，解析日期时间时使用了错误的年份导致的。

以下是复现该漏洞的步骤：

1. 安装Docker和Docker Compose。
2. 克隆Vulhub仓库到本地：git clone https://github.com/vulhub/vulhub.git
3. 进入Nginx相应的环境目录，例如cd vulhub/nginx/CVE-2019-9193
4. 运行docker-compose up -d启动环境
5. 使用工具如curl或者wget发送带有特制的If-Modified-Since头的请求。

以下是一个使用curl发送请求的例子：

curl -H 'If-Modified-Since: Sat, 01 Jan 2016 00:00:01 GMT' http://your-nginx-host

如果Nginx版本在2019年9月以后的安全更新补丁发布之前的版本，则可能会出现相应的漏洞。在实际情况中，你需要确保Nginx的版本与漏洞描述相符合，并且使用的If-Modified-Since头也要正确设置。

注意：在实际的渗透测试中，请确保你已经得到了目标的授权，并且不要对任何系统造成破坏。