php - 通过 PHP 或 Apache 从服务器端上传 HTTP 文件

Question

当上传大文件(>100M)到服务器时，PHP 总是首先接受来自浏览器的整个数据 POST。我们无法注入(inject)上传过程。

例如，在整个数据发送到服务器之前检查“token”的值是不可能在我的 PHP 代码中:

<form enctype="multipart/form-data" action="upload.php?token=XXXXXX" method="POST">
    <input type="hidden" name="MAX_FILE_SIZE" value="3000000" />
    Send this file: <input name="userfile" type="file" />
    <input type="submit" value="Send File" />
</form>

所以我尝试使用 mod_rewrite像这样:

RewriteEngine On
RewriteMap mymap prg:/tmp/map.php
RewriteCond %{QUERY_STRING} ^token=(.*)$ [NC]
RewriteRule ^/upload/fake.php$ ${mymap:%1} [L]

map .php

#!/usr/bin/php
<?php
define("REAL_TARGET", "/upload/real.php\n");
define("FORBIDDEN", "/upload/forbidden.html\n");

$handle = fopen ("php://stdin","r");
while($token = trim(fgets($handle))) {
file_put_contents("/tmp/map.log", $token."\n", FILE_APPEND);
    if (check_token($token)) {
        echo REAL_TARGET;
    } else {
        echo FORBIDDEN;
    }
}

function check_token ($token) {//do your own security check
    return substr($token,0,4) === 'alix';
}

但是......它失败了 再次 . mod_rewrite在这种情况下看起来工作太晚了。数据仍然完全传输。

然后我尝试了 Node.js ，像这样(代码片段):

var stream = new multipart.Stream(req);
stream.addListener('part', function(part) {
    sys.print(req.uri.params.token+"\n");
    if (req.uri.params.token != "xxxx") {//check token
      res.sendHeader(200, {'Content-Type': 'text/plain'});
      res.sendBody('Incorrect token!');
      res.finish();
      sys.puts("\n=> Block");
      return false;
    }

结果是...失败 再次 .

所以请帮我找到解决这个问题的正确路径，或者告诉我没有办法。

相关问题:

Can PHP (with Apache or Nginx) check HTTP header before POST request finished?

Can some tell me how to make this script check for the password before it starts the upload process instead of after the file is uploaded?

Answer 1

首先，you can try this code yourself using the GitHub repo I created for this .只需克隆存储库并运行 node header .
(剧透，如果您正在阅读本文，并且在时间压力下需要工作而没有心情学习(:()，最后有一个更简单的解决方案)
总体思路
这是一个很好的问题。您要的是很有可能和 没有客户端需要，只是更深入地了解 HTTP 协议(protocol)的工作原理，同时展示 node.js 是如何运行的:)
如果我们深入到底层 TCP protocol，这可以变得容易。并针对此特定情况自行处理 HTTP 请求。 Node.js 允许您使用内置的 net module 轻松完成此操作。 .
HTTP 协议(protocol)
首先，让我们看看 HTTP 请求是如何工作的。
An HTTP request由以 CRLF ( \r\n ) 分隔的键:值对的一般格式的标题部分组成。我们知道，当我们到达双 CRLF(即 \r\n\r\n)时，标题部分就结束了。
典型的 HTTP GET 请求可能如下所示:

GET /resource HTTP/1.1  
Cache-Control: no-cache  
User-Agent: Mozilla/5.0 

Hello=World&stuff=other

“空行”之前的顶部是标题部分，底部是请求的正文。您的请求在正文部分看起来会有所不同，因为它是用 multipart/form-data 编码的。但标题将保持相似让我们探索这如何适用于我们。
nodejs中的TCP
我们可以在 TCP 中监听原始请求并读取我们得到的数据包，直到我们读取我们谈到的双 crlf。然后我们将检查我们已经拥有的短标题部分，以进行我们需要的任何验证。在我们这样做之后，我们可以在验证没有通过的情况下结束请求(例如通过简单地结束 TCP 连接)，或者通过它。这允许我们不接收或读取请求正文，而只接收小得多的 header 。
将其嵌入到现有应用程序中的一种简单方法是将来自它的请求代理到特定用例的实际 HTTP 服务器。
实现细则
此解决方案是 作为裸露的骨头 正如它得到的那样。这只是一个建议。
这是工作流程:

我们需要 net node.js 中的模块，它允许我们在 node.js 中创建 tcp 服务器

使用 net 创建 TCP 服务器将监听数据的模块:var tcpServer = net.createServer(function (socket) {... .不要忘记告诉它监听正确的端口

在该回调中，监听数据事件 socket.on("data",function(data){ ，每当数据包到达时就会触发。

从 'data' 事件中读取传递缓冲区的数据，并将其存储在变量

中

检查双 CRLF，这确保请求 HEADER 部分已结束 according to the HTTP protocol

假设验证是一个 header (用你的话来说)，在解析 后检查它只是标题 ,(也就是我们得到了双CRLF)。这在检查内容长度 header 时也有效。

如果您注意到标题未 checkout ，请调用 socket.end()这将关闭连接。

这里有一些我们会用到的东西
一种读取标题的方法:

function readHeaders(headers) {
    var parsedHeaders = {};
    var previous = "";    
    headers.forEach(function (val) {
        // check if the next line is actually continuing a header from previous line
        if (isContinuation(val)) {
            if (previous !== "") {
                parsedHeaders[previous] += decodeURIComponent(val.trimLeft());
                return;
            } else {
                throw new Exception("continuation, but no previous header");
            }
        }

        // parse a header that looks like : "name: SP value".
        var index = val.indexOf(":");

        if (index === -1) {
            throw new Exception("bad header structure: ");
        }

        var head = val.substr(0, index).toLowerCase();
        var value = val.substr(index + 1).trimLeft();

        previous = head;
        if (value !== "") {
            parsedHeaders[head] = decodeURIComponent(value);
        } else {
            parsedHeaders[head] = null;
        }
    });
    return parsedHeaders;
};

一种检查数据事件缓冲区中双 CRLF 的方法，如果它存在于对象中，则返回其位置:

function checkForCRLF(data) {
    if (!Buffer.isBuffer(data)) {
        data = new Buffer(data,"utf-8");
    }
    for (var i = 0; i < data.length - 1; i++) {
        if (data[i] === 13) { //\r
            if (data[i + 1] === 10) { //\n
                if (i + 3 < data.length && data[i + 2] === 13 && data[i + 3] === 10) {
                    return { loc: i, after: i + 4 };
                }
            }
        } else if (data[i] === 10) { //\n

            if (data[i + 1] === 10) { //\n
                return { loc: i, after: i + 2 };
            }
        }
    }    
    return { loc: -1, after: -1337 };
};

而这个小实用方法:

function isContinuation(str) {
    return str.charAt(0) === " " || str.charAt(0) === "\t";
}

执行

var net = require("net"); // To use the node net module for TCP server. Node has equivalent modules for secure communication if you'd like to use HTTPS

//Create the server
var server = net.createServer(function(socket){ // Create a TCP server
    var req = []; //buffers so far, to save the data in case the headers don't arrive in a single packet
    socket.on("data",function(data){
        req.push(data); // add the new buffer
        var check = checkForCRLF(data);
        if(check.loc !== -1){ // This means we got to the end of the headers!
            var dataUpToHeaders= req.map(function(x){
                return x.toString();//get buffer strings
            }).join("");
            //get data up to /r/n
            dataUpToHeaders = dataUpToHeaders.substring(0,check.after);
            //split by line
            var headerList = dataUpToHeaders.trim().split("\r\n");
            headerList.shift() ;// remove the request line itself, eg GET / HTTP1.1
            console.log("Got headers!");
            //Read the headers
            var headerObject = readHeaders(headerList);
            //Get the header with your token
            console.log(headerObject["your-header-name"]);

            // Now perform all checks you need for it
            /*
            if(!yourHeaderValueValid){
                socket.end();
            }else{
                         //continue reading request body, and pass control to whatever logic you want!
            }
            */


        }
    });
}).listen(8080); // listen to port 8080 for the sake of the example

如果您有任何问题随时问 :)
好吧，我撒谎了，还有更简单的方法!
但这有什么乐趣呢？如果您最初跳过这里，您将不会了解 HTTP 的工作原理:)
Node.js 有一个内置的 http模块。由于 node.js 中的请求本质上是分块的，尤其是长请求，你可以在没有更深入的协议(protocol)理解的情况下实现同样的事情。
这一次，让我们用 http创建http服务器的模块

server = http.createServer( function(req, res) { //create an HTTP server
    // The parameters are request/response objects
    // check if method is post, and the headers contain your value.
    // The connection was established but the body wasn't sent yet,
    // More information on how this works is in the above solution
    var specialRequest = (req.method == "POST") && req.headers["YourHeader"] === "YourTokenValue";
    if(specialRequest ){ // detect requests for special treatment
      // same as TCP direct solution add chunks
      req.on('data',function(chunkOfBody){
              //handle a chunk of the message body
      });
    }else{
        res.end(); // abort the underlying TCP connection, since the request and response use the same TCP connection this will work
        //req.destroy() // destroy the request in a non-clean matter, probably not what you want.
    }
}).listen(8080);

这是基于事实 request在 nodejs 中处理 http默认情况下，模块实际上在发送 header 后 Hook (但没有执行其他任何操作)。 (this in the server module , this in the parser module)
用户 igorw建议使用 100 Continue 更简洁的解决方案假设您定位的浏览器支持它。 100 Continue 是一个状态代码，旨在完成您正在尝试执行的操作:

The purpose of the 100 (Continue) status (see section 10.1.1) is toallow a client that is sending a request message with a request bodyto determine if the origin server is willing to accept the request(based on the request headers) before the client sends the requestbody. In some cases, it might either be inappropriate or highlyinefficient for the client to send the body if the server will rejectthe message without looking at the body.

这里是 :

var http = require('http');
 
function handle(req, rep) {
    req.pipe(process.stdout); // pipe the request to the output stream for further handling
    req.on('end', function () {
        rep.end();
        console.log('');
    });
}
 
var server = new http.Server();
 
server.on('checkContinue', function (req, rep) {
    if (!req.headers['x-foo']) {
        console.log('did not have foo');
        rep.writeHead(400);
        rep.end();
        return;
    }
 
    rep.writeContinue();
    handle(req, rep);
});
 
server.listen(8080);

您可以看到示例输入/输出 here .这将需要您的请求使用适当的 Expect: 触发。标题。