Проблема атаки на отказ в обслуживании в книге "Программирование Unix Networking"

Question

Я читаю "Программирование Unix Networking" 3-е издание.

Я сталкиваюсь с вопросом в разделе 6.8 "TCP Echo Server (Revisited)", здесь представлен код, представленный ниже:

#include    "unp.h"

int
main(int argc, char **argv)
{
    int                 i, maxi, maxfd, listenfd, connfd, sockfd;
    int                 nready, client[FD_SETSIZE];
    ssize_t             n;
    fd_set              rset, allset;
    char                buf[MAXLINE];
    socklen_t           clilen;
    struct sockaddr_in  cliaddr, servaddr;

    listenfd = Socket(AF_INET, SOCK_STREAM, 0);

    bzero(&servaddr, sizeof(servaddr));
    servaddr.sin_family      = AF_INET;
    servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    servaddr.sin_port        = htons(SERV_PORT);

    Bind(listenfd, (SA *) &servaddr, sizeof(servaddr));

    Listen(listenfd, LISTENQ);

    maxfd = listenfd;           /* initialize */
    maxi = -1;                  /* index into client[] array */
    for (i = 0; i < FD_SETSIZE; i++)
        client[i] = -1;         /* -1 indicates available entry */
    FD_ZERO(&allset);
    FD_SET(listenfd, &allset);

    for ( ; ; ) {
        rset = allset;      /* structure assignment */
        nready = Select(maxfd+1, &rset, NULL, NULL, NULL);

        if (FD_ISSET(listenfd, &rset)) {    /* new client connection */
            clilen = sizeof(cliaddr);
            connfd = Accept(listenfd, (SA *) &cliaddr, &clilen);

            for (i = 0; i < FD_SETSIZE; i++)
                if (client[i] < 0) {
                    client[i] = connfd; /* save descriptor */
                    break;
                }
            if (i == FD_SETSIZE)
                err_quit("too many clients");

            FD_SET(connfd, &allset);    /* add new descriptor to set */
            if (connfd > maxfd)
                maxfd = connfd;         /* for select */
            if (i > maxi)
                maxi = i;               /* max index in client[] array */

            if (--nready <= 0)
                continue;               /* no more readable descriptors */
        }

        for (i = 0; i <= maxi; i++) {   /* check all clients for data */
            if ( (sockfd = client[i]) < 0)
                continue;
            **if (FD_ISSET(sockfd, &rset)) {
                if ( (n = Read(sockfd, buf, MAXLINE)) == 0) {
                        /*4connection closed by client */
                    Close(sockfd);
                    FD_CLR(sockfd, &allset);
                    client[i] = -1;
                } else
                    Writen(sockfd, buf, n);**

                if (--nready <= 0)
                    break;              /* no more readable descriptors */
            }
        }
    }
}

Об этой программе автор сказал, что сервер будет страдать от DDOS-атаки, как показано ниже: введите описание изображения здесь

Дело в том, что когда клиентский запрос приходит, сервер читает всю строку, а затем выводит ее. Но в этом коде мы видим, что сервер использует функцию чтения данных из клиента, а не ReadLine или Readn, последние не будут возвращаться, пока не встретят '\n' или не получат данные заданного размера, но функция чтения немедленно вернется в этом случае. Функция чтения просто оболочка системного вызова "чтение", как показано ниже:

ssize_t Read(int fd, void *ptr, size_t nbytes)
{
    ssize_t     n;

    if ( (n = read(fd, ptr, nbytes)) == -1)
        err_sys("read error");
    return(n);
}

Поэтому я запутался, почему этот сервер будет страдать от атаки ddos?

Кто-нибудь может это уточнить? Большое спасибо!

Answer 1

Я думаю, что путаница связана с возможной разницей между вторым изданием и третьим изданием книги.

У меня есть 2-е издание, и в нем "Чтение" на самом деле является "Readline". Тогда объяснение имеет смысл, потому что Readline настаивает на чтении до новой строки.

У меня нет копии 3-го издания для сравнения.

Что касается объяснения от Drunken Code Monkey, правда, чтение блокируется, однако оно защищено выбором, который гарантирует, что чтение вызывается, только если есть активность в сокете (либо отключение, либо как минимум 1 байт для читать). Таким образом, гарантируется, что чтение не будет блокироваться. Но см. Мое объяснение относительно того, заменен ли Read на Readline (как во 2-м издании)

См. Также предыдущий пост о разъяснении сетевого переполнения в Unix.

Answer 2

Согласно ответу Стефана, вот пример, чтобы проиллюстрировать правильную обработку соединения в многопоточном TCP-сервере. Обратите внимание, что я не достаточно удобен в разработке под Linux, чтобы писать это легко, так что это C#, но поток программы должен быть таким же. Считайте это псевдокодом, если нужно.

    // We use a wait handle here to synchronize the client threads with the main thread.
    private static AutoResetEvent _waitHandle = new AutoResetEvent(false);

    static void Main(string[] args)
    {
        // Start the server on port 1337
        StartServer(1337);
    }

    private static void StartServer(int port)
    {
        // Create a connection listener
        var listener = new TcpListener(IPAddress.Any, port);

        try
        {
            // Start the listener
            listener.Start();
            while (true)
            {
                // Wait for a connection, and defer connection handling asynchronously.
                listener.BeginAcceptTcpClient(new AsyncCallback(HandleAsyncConnection), listener);
                _waitHandle.WaitOne();
                _waitHandle.Reset();
            }
        }
        catch (SocketException ex)
        {
            // Handle socket errors or any other exception you deem necessary here
        }
        finally
        {
            // Stop the server.
            listener.Stop();
        }
    }

    private static void HandleAsyncConnection(IAsyncResult state)
    {
        // Get the listener and the client references
        var listener = (TcpListener)state.AsyncState;
        using (var tcpClient = listener.EndAcceptTcpClient(state))
        {
            // Signal the main thread that we have started handling this request.
            // At this point the server is ready to handle another connection, and no amount
            // of tomfoolery on the client's side will prevent this.
            _waitHandle.Set();

            // Declare buffers
            var inBuff = new byte[tcpClient.ReceiveBufferSize];
            var outBuff = new byte[tcpClient.SendBufferSize];

            // Get the connection stream
            using (var stream = tcpClient.GetStream())
            {
                try
                {
                    // Read some data into inBuff
                    stream.Read(inBuff, 0, tcpClient.ReceiveBufferSize);

                    // Do something with the data here, put response in outBuff...

                    // Send response to client
                    stream.Write(outBuff, 0, outBuff.Length);
                }
                catch (SocketException ex)
                {
                    // Handle socket errors or any other exception you deem necessary here
                }
            }
        }
    }