Code Coverage: vinyl-cache/bin/vinyld/http2/cache_http2_hpack.c
 
82217aa4fc7094b3610340078afaf78cd95a8ec9
 
0
/*-
1
 * Copyright (c) 2016 Varnish Software AS
2
 * All rights reserved.
3
 *
4
 * Author: Martin Blix Grydeland <martin@varnish-software.com>
5
 *
6
 * SPDX-License-Identifier: BSD-2-Clause
7
 *
8
 * Redistribution and use in source and binary forms, with or without
9
 * modification, are permitted provided that the following conditions
10
 * are met:
11
 * 1. Redistributions of source code must retain the above copyright
12
 *    notice, this list of conditions and the following disclaimer.
13
 * 2. Redistributions in binary form must reproduce the above copyright
14
 *    notice, this list of conditions and the following disclaimer in the
15
 *    documentation and/or other materials provided with the distribution.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
18
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
21
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
27
 * SUCH DAMAGE.
28
 *
29
 */
30
31
#include "config.h"
32
33
#include "cache/cache_int.h"
34
35
#include <ctype.h>
36
#include <stdio.h>
37
38
#include "http2/cache_http2.h"
39
#include "vct.h"
40
41
static void
42
h2h_assert_ready(const struct h2h_decode *d)
43 630
{
44
45 630
        CHECK_OBJ_NOTNULL(d, H2H_DECODE_MAGIC);
46 630
        AN(d->out);
47 630
        assert(d->namelen >= 2); /* 2 chars from the ": " that we added */
48 630
        assert(d->namelen <= d->out_u);
49 630
        assert(d->out[d->namelen - 2] == ':');
50 630
        assert(d->out[d->namelen - 1] == ' ');
51 630
}
52
53
// rfc9113,l,2493,2528
54
static h2_error
55
h2h_checkhdr(struct vsl_log *vsl, txt nm, txt val)
56 630
{
57 630
        const char *p;
58 630
        int l;
59 630
        enum {
60 630
                FLD_NAME_FIRST,
61 630
                FLD_NAME,
62 630
                FLD_VALUE_FIRST,
63 630
                FLD_VALUE
64 630
        } state;
65
66 630
        if (Tlen(nm) == 0) {
67 0
                VSLb(vsl, SLT_BogoHeader, "Empty name");
68 0
                return (H2SE_PROTOCOL_ERROR);
69 0
        }
70
71
        // VSLb(vsl, SLT_Debug, "CHDR [%.*s] [%.*s]",
72
        //     (int)Tlen(nm), nm.b, (int)Tlen(val), val.b);
73
74 630
        l = vmin_t(int, Tlen(nm) + 2 + Tlen(val), 20);
75 630
        state = FLD_NAME_FIRST;
76 4105
        Tforeach(p, nm) {
77 4105
                switch(state) {
78 630
                case FLD_NAME_FIRST:
79 630
                        state = FLD_NAME;
80 630
                        if (*p == ':')
81 498
                                break;
82
                        /* FALLTHROUGH */
83 3607
                case FLD_NAME:
84 3607
                        if (isupper(*p)) {
85 1
                                VSLb(vsl, SLT_BogoHeader,
86 1
                                    "Illegal field header name (upper-case): %.*s",
87 1
                                    l, nm.b);
88 1
                                return (H2SE_PROTOCOL_ERROR);
89 1
                        }
90 3606
                        if (!vct_istchar(*p) || *p == ':') {
91 3
                                VSLb(vsl, SLT_BogoHeader,
92 3
                                    "Illegal field header name (non-token): %.*s",
93 3
                                    l, nm.b);
94 3
                                return (H2SE_PROTOCOL_ERROR);
95 3
                        }
96 3603
                        break;
97 3603
                default:
98 0
                        WRONG("http2 field name validation state");
99 4105
                }
100 4105
        }
101
102 626
        state = FLD_VALUE_FIRST;
103 31792
        Tforeach(p, val) {
104 31792
                switch(state) {
105 619
                case FLD_VALUE_FIRST:
106 619
                        if (vct_issp(*p)) {
107 9
                                VSLb(vsl, SLT_BogoHeader,
108 9
                                    "Illegal field value 0x%02x start %.*s",
109 9
                                    *p, l, nm.b);
110 9
                                return (H2SE_PROTOCOL_ERROR);
111 9
                        }
112 610
                        state = FLD_VALUE;
113
                        /* FALLTHROUGH */
114 31783
                case FLD_VALUE:
115 31783
                        if (!vct_ishdrval(*p)) {
116 1
                                VSLb(vsl, SLT_BogoHeader,
117 1
                                    "Illegal field value 0x%02x %.*s",
118 1
                                    *p, l, nm.b);
119 1
                                return (H2SE_PROTOCOL_ERROR);
120 1
                        }
121 31782
                        break;
122 31782
                default:
123 0
                        WRONG("http2 field value validation state");
124 31792
                }
125 31792
        }
126 616
        if (state == FLD_VALUE && vct_issp(val.e[-1])) {
127 2
                VSLb(vsl, SLT_BogoHeader,
128 2
                    "Illegal field value 0x%02x (end) at %.*s",
129 2
                    val.e[-1], l, nm.b);
130 2
                return (H2SE_PROTOCOL_ERROR);
131 2
        }
132 614
        return (0);
133 616
}
134
135
static h2_error
136
h2h_addhdr(struct http *hp, struct h2h_decode *d)
137 630
{
138
        /* XXX: This might belong in cache/cache_http.c */
139 630
        txt hdr, nm, val;
140 630
        int disallow_empty;
141 630
        const char *p;
142 630
        unsigned n, has_dup;
143 630
        h2_error err;
144
145 630
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
146 630
        h2h_assert_ready(d);
147
148
        /* Assume hdr is by default a regular header from what we decoded. */
149 630
        hdr.b = d->out;
150 630
        hdr.e = hdr.b + d->out_u;
151 630
        n = hp->nhd;
152
153
        /* nm and val are separated by ": " */
154 630
        nm.b = hdr.b;
155 630
        nm.e = nm.b + d->namelen - 2;
156 630
        val.b = nm.e + 2;
157 630
        val.e = hdr.e;
158
159 630
        err = h2h_checkhdr(hp->vsl, nm, val);
160 630
        if (err != NULL)
161 16
                return (err);
162
163 614
        disallow_empty = 0;
164 614
        has_dup = 0;
165
166 614
        if (Tlen(hdr) > cache_param->http_req_hdr_len) {
167 1
                VSLb(hp->vsl, SLT_BogoHeader, "Header too large: %.20s", hdr.b);
168 1
                return (H2SE_ENHANCE_YOUR_CALM);
169 1
        }
170
171
        /* Match H/2 pseudo headers */
172
        /* XXX: Should probably have some include tbl for pseudo-headers */
173 613
        if (Tstreq(nm, ":method")) {
174 154
                hdr.b = val.b;
175 154
                n = HTTP_HDR_METHOD;
176 154
                disallow_empty = 1;
177
178
                /* Check HTTP token */
179 492
                Tforeach(p, hdr) {
180 492
                        if (!vct_istchar(*p))
181 0
                                return (H2SE_PROTOCOL_ERROR);
182 492
                }
183 459
        } else if (Tstreq(nm, ":path")) {
184 161
                hdr.b = val.b;
185 161
                n = HTTP_HDR_URL;
186 161
                disallow_empty = 1;
187
188
                // rfc9113,l,2693,2705
189 161
                if (Tlen(val) > 0 && val.b[0] != '/' && !Tstreq(val, "*")) {
190 2
                        VSLb(hp->vsl, SLT_BogoHeader,
191 2
                            "Illegal :path pseudo-header %.*s",
192 2
                            (int)Tlen(val), val.b);
193 2
                        return (H2SE_PROTOCOL_ERROR);
194 2
                }
195
196
                /* Path cannot contain LWS or CTL */
197 370
                Tforeach(p, hdr) {
198 370
                        if (vct_islws(*p) || vct_isctl(*p))
199 0
                                return (H2SE_PROTOCOL_ERROR);
200 370
                }
201 298
        } else if (Tstreq(nm, ":scheme")) {
202
                /* XXX: What to do about this one? (typically
203
                   "http" or "https"). For now set it as a normal
204
                   header, stripping the first ':'. */
205 155
                hdr.b++;
206 155
                has_dup = d->has_scheme;
207 155
                d->has_scheme = 1;
208 155
                disallow_empty = 1;
209
210
                /* Check HTTP token */
211 613
                Tforeach(p, val) {
212 613
                        if (!vct_istchar(*p))
213 0
                                return (H2SE_PROTOCOL_ERROR);
214 613
                }
215 155
        } else if (Tstreq(nm, ":authority")) {
216
                /* NB: we inject "host" in place of "rity" for
217
                 * the ":authority" pseudo-header.
218
                 */
219 18
                vmemcpy(d->out + 6, "host", 4);
220 18
                hdr.b += 6;
221 18
                nm = Tstr(":authority"); /* preserve original */
222 18
                has_dup = d->has_authority;
223 18
                d->has_authority = 1;
224 125
        } else if (nm.b[0] == ':') {
225 3
                VSLb(hp->vsl, SLT_BogoHeader,
226 3
                    "Unknown pseudo-header: %.*s",
227 3
                    vmin_t(int, Tlen(hdr), 20), hdr.b);
228 3
                return (H2SE_PROTOCOL_ERROR);   // rfc7540,l,2990,2992
229 3
        }
230
231 608
        if (disallow_empty && Tlen(val) == 0) {
232 6
                VSLb(hp->vsl, SLT_BogoHeader,
233 6
                    "Empty pseudo-header %.*s",
234 6
                    (int)Tlen(nm), nm.b);
235 6
                return (H2SE_PROTOCOL_ERROR);
236 6
        }
237
238 602
        if (n >= HTTP_HDR_FIRST) {
239
                /* Check for space in struct http */
240 293
                if (n >= hp->shd) {
241 1
                        VSLb(hp->vsl, SLT_LostHeader,
242 1
                            "Too many headers: %.*s",
243 1
                            vmin_t(int, Tlen(hdr), 20), hdr.b);
244 1
                        return (H2SE_ENHANCE_YOUR_CALM);
245 1
                }
246 292
                hp->nhd++;
247 292
                AZ(hp->hd[n].b);
248 292
        }
249
250 601
        if (has_dup || hp->hd[n].b != NULL) {
251 5
                assert(nm.b[0] == ':');
252 5
                VSLb(hp->vsl, SLT_BogoHeader,
253 5
                    "Duplicate pseudo-header %.*s",
254 5
                    (int)Tlen(nm), nm.b);
255 5
                return (H2SE_PROTOCOL_ERROR);   // rfc7540,l,3158,3162
256 5
        }
257
258 596
        hp->hd[n] = hdr;
259 596
        return (0);
260 601
}
261
262
static void
263
h2h_decode_init(const struct h2_sess *h2, struct ws *ws)
264 191
{
265 191
        struct h2h_decode *d;
266
267 191
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
268 191
        CHECK_OBJ_NOTNULL(ws, WS_MAGIC);
269
270 191
        AN(h2->decode);
271 191
        d = h2->decode;
272 191
        INIT_OBJ(d, H2H_DECODE_MAGIC);
273 191
        VHD_Init(d->vhd);
274 191
        d->out_l = WS_ReserveSize(ws, cache_param->http_req_size);
275
        /*
276
         * Can't do any work without any buffer
277
         * space. Require non-zero size.
278
         */
279 191
        XXXAN(d->out_l);
280 382
        d->out = WS_Reservation(ws);
281
282 191
        if (cache_param->h2_max_header_list_size == 0)
283 187
                d->limit =
284 187
                    (long)h2->local_settings.max_header_list_size * 3 / 2;
285 4
        else
286 4
                d->limit = cache_param->h2_max_header_list_size;
287
288
        //  d->limit < cache_param->http_req_size
289 382
        if (d->limit < h2->local_settings.max_header_list_size)
290 0
                d->limit = INT64_MAX;
291
292 382
        d->ws = ws;
293 382
}
294
295
void
296
h2h_decode_hdr_init(const struct h2_sess *h2)
297 191
{
298
299 191
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
300 191
        CHECK_OBJ_NOTNULL(h2->new_req, REQ_MAGIC);
301 191
        CHECK_OBJ_NOTNULL(h2->new_req->http, HTTP_MAGIC);
302 191
        h2h_decode_init(h2, h2->new_req->ws);
303 191
}
304
305
/* Possible error returns:
306
 *
307
 * H2E_COMPRESSION_ERROR: Lost compression state due to incomplete header
308
 * block. This is a connection level error.
309
 *
310
 * H2E_ENHANCE_YOUR_CALM: Ran out of workspace or http header space. This
311
 * is a stream level error.
312
 */
313
h2_error
314
h2h_decode_hdr_fini(const struct h2_sess *h2)
315 191
{
316 191
        h2_error ret;
317 191
        struct h2h_decode *d;
318
319 191
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
320 191
        d = h2->decode;
321 191
        CHECK_OBJ_NOTNULL(h2->new_req, REQ_MAGIC);
322 191
        CHECK_OBJ_NOTNULL(d, H2H_DECODE_MAGIC);
323 191
        WS_ReleaseP(d->ws, d->out);
324 191
        if (d->vhd_ret != VHD_OK) {
325
                /* HPACK header block didn't finish at an instruction
326
                   boundary */
327 37
                VSLb(h2->new_req->http->vsl, SLT_BogoHeader,
328 37
                    "HPACK compression error/fini (%s)", VHD_Error(d->vhd_ret));
329 37
                ret = H2CE_COMPRESSION_ERROR;
330 154
        } else if (d->error == NULL && !d->has_scheme) {
331 4
                H2S_Lock_VSLb(h2, SLT_Debug, "Missing :scheme");
332 4
                ret = H2SE_MISSING_SCHEME; //rfc7540,l,3087,3090
333 4
        } else
334 150
                ret = d->error;
335 191
        FINI_OBJ(d);
336 191
        if (ret == H2SE_REQ_SIZE) {
337 1
                VSLb(h2->new_req->http->vsl, SLT_LostHeader,
338 1
                    "Header list too large");
339 1
        }
340 191
        return (ret);
341 191
}
342
343
/* Possible error returns:
344
 *
345
 * H2E_COMPRESSION_ERROR: Lost compression state due to invalid header
346
 * block. This is a connection level error.
347
 *
348
 * H2E_PROTOCOL_ERROR: Malformed header or duplicate pseudo-header.
349
 *                     Violation of field name/value charsets
350
 */
351
h2_error
352
h2h_decode_bytes(struct h2_sess *h2, const uint8_t *in, size_t in_l)
353 205
{
354 205
        struct http *hp;
355 205
        struct h2h_decode *d;
356 205
        size_t in_u = 0;
357 205
        const char *r, *e;
358
359 205
        CHECK_OBJ_NOTNULL(h2, H2_SESS_MAGIC);
360 205
        CHECK_OBJ_NOTNULL(h2->new_req, REQ_MAGIC);
361 205
        hp = h2->new_req->http;
362 205
        CHECK_OBJ_NOTNULL(hp, HTTP_MAGIC);
363 205
        d = h2->decode;
364 205
        CHECK_OBJ_NOTNULL(d, H2H_DECODE_MAGIC);
365 205
        CHECK_OBJ_NOTNULL(d->ws, WS_MAGIC);
366 410
        r = WS_Reservation(d->ws);
367 205
        AN(r);
368 410
        e = r + WS_ReservationSize(d->ws);
369
370
        /* Only H2E_ENHANCE_YOUR_CALM indicates that we should continue
371
           processing. Other errors should have been returned and handled
372
           by the caller. */
373 205
        if (d->error != NULL)
374 4
                assert(H2_ERROR_MATCH(d->error, H2SE_ENHANCE_YOUR_CALM));
375
376 1467
        while (d->limit >= 0) {
377 1465
                AN(d->out);
378 1465
                assert(d->out_u <= d->out_l);
379 1465
                d->vhd_ret = VHD_Decode(d->vhd, h2->dectbl, in, in_l, &in_u,
380 1465
                    d->out, d->out_l, &d->out_u);
381
382 1465
                if (d->vhd_ret < 0) {
383 2
                        H2S_Lock_VSLb(h2, SLT_BogoHeader,
384 2
                            "HPACK compression error (%s)",
385 2
                            VHD_Error(d->vhd_ret));
386 2
                        d->error = H2CE_COMPRESSION_ERROR;
387 2
                        break;
388 1463
                } else if (d->vhd_ret == VHD_OK || d->vhd_ret == VHD_MORE) {
389 169
                        assert(in_u == in_l);
390 169
                        break;
391 169
                }
392
393 1294
                if (H2_ERROR_MATCH(d->error, H2SE_ENHANCE_YOUR_CALM)) {
394 28
                        d->limit -= d->out_u;
395 28
                        d->out_u = 0;
396 28
                        assert(d->out_u < d->out_l);
397 28
                        continue;
398 28
                }
399
400 1266
                switch (d->vhd_ret) {
401 1
                case VHD_NAME_SEC:
402
                        /* XXX: header flag for never-indexed header */
403 633
                case VHD_NAME:
404 633
                        assert(d->namelen == 0);
405 633
                        if (d->out_l - d->out_u < 2) {
406 0
                                d->error = H2SE_REQ_SIZE;
407 0
                                break;
408 0
                        }
409 633
                        d->out[d->out_u++] = ':';
410 633
                        d->out[d->out_u++] = ' ';
411 633
                        d->namelen = d->out_u;
412 633
                        break;
413
414 1
                case VHD_VALUE_SEC:
415
                        /* XXX: header flag for never-indexed header */
416 630
                case VHD_VALUE:
417 630
                        assert(d->namelen > 0);
418 630
                        if (d->out_l - d->out_u < 1) {
419 0
                                d->error = H2SE_REQ_SIZE;
420 0
                                break;
421 0
                        }
422 630
                        d->error = h2h_addhdr(hp, d);
423 630
                        if (d->error)
424 34
                                break;
425 596
                        d->out[d->out_u++] = '\0'; /* Zero guard */
426 596
                        d->out += d->out_u;
427 596
                        d->out_l -= d->out_u;
428 596
                        d->limit -= d->out_u;
429 596
                        d->out_u = 0;
430 596
                        d->namelen = 0;
431 596
                        break;
432
433 3
                case VHD_BUF:
434 3
                        d->error = H2SE_REQ_SIZE;
435 3
                        break;
436
437 0
                default:
438 0
                        WRONG("Unhandled return value");
439 0
                        break;
440 1266
                }
441
442 1266
                if (H2_ERROR_MATCH(d->error, H2SE_ENHANCE_YOUR_CALM)) {
443 10
                        d->out = WS_Reservation(d->ws);
444 0
                        d->out_l = e - d->out;
445 10
                        d->limit -= d->out_u;
446 10
                        d->out_u = 0;
447 10
                        assert(d->out_l > 0);
448 1261
                } else if (d->error)
449 32
                        break;
450 1266
        }
451
452 205
        if (d->limit < 0) {
453
                /* Fatal error, the client exceeded both http_req_size
454
                 * and h2_max_header_list_size. */
455 2
                H2S_Lock_VSLb(h2, SLT_SessError, "Header list too large");
456 2
                return (H2CE_ENHANCE_YOUR_CALM);
457 2
        }
458
459 203
        if (H2_ERROR_MATCH(d->error, H2SE_ENHANCE_YOUR_CALM)) {
460
                /* Stream error, delay reporting until h2h_decode_hdr_fini so
461
                 * that we can process the complete header block. */
462 7
                return (NULL);
463 7
        }
464
465 196
        return (d->error);
466 203
}