

#include <openssl/err.h>
#include "internal/common.h"
#include "internal/quic_wire_pkt.h"

int ossl_quic_hdr_protector_init(QUIC_HDR_PROTECTOR *hpr,
                                 OSSL_LIB_CTX *libctx,
                                 const char *propq,
                                 uint32_t cipher_id,
                                 const unsigned char *quic_hp_key,
                                 size_t quic_hp_key_len)
{
    const char *cipher_name = NULL;

    switch (cipher_id) {
        case QUIC_HDR_PROT_CIPHER_AES_128:
            cipher_name = "AES-128-ECB";
            break;
        case QUIC_HDR_PROT_CIPHER_AES_256:
            cipher_name = "AES-256-ECB";
            break;
        case QUIC_HDR_PROT_CIPHER_CHACHA:
            cipher_name = "ChaCha20";
            break;
        default:
            ERR_raise(ERR_LIB_SSL, ERR_R_UNSUPPORTED);
            return 0;
    }

    hpr->cipher_ctx = EVP_CIPHER_CTX_new();
    if (hpr->cipher_ctx == NULL) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        return 0;
    }

    hpr->cipher = EVP_CIPHER_fetch(libctx, cipher_name, propq);
    if (hpr->cipher == NULL
        || quic_hp_key_len != (size_t)EVP_CIPHER_get_key_length(hpr->cipher)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        goto err;
    }

    if (!EVP_CipherInit_ex(hpr->cipher_ctx, hpr->cipher, NULL,
                           quic_hp_key, NULL, 1)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        goto err;
    }

    hpr->libctx     = libctx;
    hpr->propq      = propq;
    hpr->cipher_id  = cipher_id;
    return 1;

err:
    ossl_quic_hdr_protector_cleanup(hpr);
    return 0;
}

void ossl_quic_hdr_protector_cleanup(QUIC_HDR_PROTECTOR *hpr)
{
    EVP_CIPHER_CTX_free(hpr->cipher_ctx);
    hpr->cipher_ctx = NULL;

    EVP_CIPHER_free(hpr->cipher);
    hpr->cipher = NULL;
}

static int hdr_generate_mask(QUIC_HDR_PROTECTOR *hpr,
                             const unsigned char *sample, size_t sample_len,
                             unsigned char *mask)
{
    int l = 0;
    unsigned char dst[16];
    static const unsigned char zeroes[5] = {0};
    size_t i;

    if (hpr->cipher_id == QUIC_HDR_PROT_CIPHER_AES_128
        || hpr->cipher_id == QUIC_HDR_PROT_CIPHER_AES_256) {
        if (sample_len < 16) {
            ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
            return 0;
        }

        if (!EVP_CipherInit_ex(hpr->cipher_ctx, NULL, NULL, NULL, NULL, 1)
            || !EVP_CipherUpdate(hpr->cipher_ctx, dst, &l, sample, 16)) {
            ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
            return 0;
        }

        for (i = 0; i < 5; ++i)
            mask[i] = dst[i];
    } else if (hpr->cipher_id == QUIC_HDR_PROT_CIPHER_CHACHA) {
        if (sample_len < 16) {
            ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
            return 0;
        }

        if (!EVP_CipherInit_ex(hpr->cipher_ctx, NULL, NULL, NULL, sample, 1)
            || !EVP_CipherUpdate(hpr->cipher_ctx, mask, &l,
                                 zeroes, sizeof(zeroes))) {
            ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
            return 0;
        }
    } else {
        ERR_raise(ERR_LIB_SSL, ERR_R_INTERNAL_ERROR);
        assert(0);
        return 0;
    }

#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    
    memset(mask, 0, 5);
#endif

    return 1;
}

int ossl_quic_hdr_protector_decrypt(QUIC_HDR_PROTECTOR *hpr,
                                    QUIC_PKT_HDR_PTRS *ptrs)
{
    return ossl_quic_hdr_protector_decrypt_fields(hpr,
                                                  ptrs->raw_sample,
                                                  ptrs->raw_sample_len,
                                                  ptrs->raw_start,
                                                  ptrs->raw_pn);
}

int ossl_quic_hdr_protector_decrypt_fields(QUIC_HDR_PROTECTOR *hpr,
                                           const unsigned char *sample,
                                           size_t sample_len,
                                           unsigned char *first_byte,
                                           unsigned char *pn_bytes)
{
    unsigned char mask[5], pn_len, i;

    if (!hdr_generate_mask(hpr, sample, sample_len, mask))
        return 0;

    *first_byte ^= mask[0] & ((*first_byte & 0x80) != 0 ? 0xf : 0x1f);
    pn_len = (*first_byte & 0x3) + 1;

    for (i = 0; i < pn_len; ++i)
        pn_bytes[i] ^= mask[i + 1];

    return 1;
}

int ossl_quic_hdr_protector_encrypt(QUIC_HDR_PROTECTOR *hpr,
                                    QUIC_PKT_HDR_PTRS *ptrs)
{
    return ossl_quic_hdr_protector_encrypt_fields(hpr,
                                                  ptrs->raw_sample,
                                                  ptrs->raw_sample_len,
                                                  ptrs->raw_start,
                                                  ptrs->raw_pn);
}

int ossl_quic_hdr_protector_encrypt_fields(QUIC_HDR_PROTECTOR *hpr,
                                           const unsigned char *sample,
                                           size_t sample_len,
                                           unsigned char *first_byte,
                                           unsigned char *pn_bytes)
{
    unsigned char mask[5], pn_len, i;

    if (!hdr_generate_mask(hpr, sample, sample_len, mask))
        return 0;

    pn_len = (*first_byte & 0x3) + 1;
    for (i = 0; i < pn_len; ++i)
        pn_bytes[i] ^= mask[i + 1];

    *first_byte ^= mask[0] & ((*first_byte & 0x80) != 0 ? 0xf : 0x1f);
    return 1;
}

int ossl_quic_wire_decode_pkt_hdr(PACKET *pkt,
                                  size_t short_conn_id_len,
                                  int partial,
                                  int nodata,
                                  QUIC_PKT_HDR *hdr,
                                  QUIC_PKT_HDR_PTRS *ptrs)
{
    unsigned int b0;
    unsigned char *pn = NULL;
    size_t l = PACKET_remaining(pkt);

    if (ptrs != NULL) {
        ptrs->raw_start         = (unsigned char *)PACKET_data(pkt);
        ptrs->raw_sample        = NULL;
        ptrs->raw_sample_len    = 0;
        ptrs->raw_pn            = NULL;
    }

    if (l < QUIC_MIN_VALID_PKT_LEN
        || !PACKET_get_1(pkt, &b0))
        return 0;

    hdr->partial    = partial;
    hdr->unused     = 0;
    hdr->reserved   = 0;

    if ((b0 & 0x80) == 0) {
        
        if (short_conn_id_len > QUIC_MAX_CONN_ID_LEN)
            return 0;

        if ((b0 & 0x40) == 0 
            || l < QUIC_MIN_VALID_PKT_LEN_CRYPTO)
            return 0;

        hdr->type       = QUIC_PKT_TYPE_1RTT;
        hdr->fixed      = 1;
        hdr->spin_bit   = (b0 & 0x20) != 0;
        if (partial) {
            hdr->key_phase  = 0; 
            hdr->pn_len     = 0; 
            hdr->reserved   = 0; 
        } else {
            hdr->key_phase  = (b0 & 0x04) != 0;
            hdr->pn_len     = (b0 & 0x03) + 1;
            hdr->reserved   = (b0 & 0x18) >> 3;
        }

        
        if (!PACKET_copy_bytes(pkt, hdr->dst_conn_id.id, short_conn_id_len))
            return 0;

        hdr->dst_conn_id.id_len = (unsigned char)short_conn_id_len;

        
        memset(hdr->pn, 0, sizeof(hdr->pn));
        pn = (unsigned char *)PACKET_data(pkt);
        if (partial) {
            if (!PACKET_forward(pkt, sizeof(hdr->pn)))
                return 0;
        } else {
            if (!PACKET_copy_bytes(pkt, hdr->pn, hdr->pn_len))
                return 0;
        }

        
        hdr->version            = 0;
        hdr->src_conn_id.id_len = 0;
        hdr->token              = NULL;
        hdr->token_len          = 0;

        
        hdr->len                = PACKET_remaining(pkt);
        hdr->data               = PACKET_data(pkt);

        
        if (!PACKET_forward(pkt, hdr->len))
            return 0;
    } else {
        
        unsigned long version;
        unsigned int dst_conn_id_len, src_conn_id_len, raw_type;

        if (!PACKET_get_net_4(pkt, &version))
            return 0;

        
        if (version != 0 && (b0 & 0x40) == 0)
            return 0;

        if (!PACKET_get_1(pkt, &dst_conn_id_len)
            || dst_conn_id_len > QUIC_MAX_CONN_ID_LEN
            || !PACKET_copy_bytes(pkt, hdr->dst_conn_id.id, dst_conn_id_len)
            || !PACKET_get_1(pkt, &src_conn_id_len)
            || src_conn_id_len > QUIC_MAX_CONN_ID_LEN
            || !PACKET_copy_bytes(pkt, hdr->src_conn_id.id, src_conn_id_len))
            return 0;

        hdr->version            = (uint32_t)version;
        hdr->dst_conn_id.id_len = (unsigned char)dst_conn_id_len;
        hdr->src_conn_id.id_len = (unsigned char)src_conn_id_len;

        if (version == 0) {
            
            hdr->type       = QUIC_PKT_TYPE_VERSION_NEG;
            hdr->fixed      = (b0 & 0x40) != 0;

            hdr->data       = PACKET_data(pkt);
            hdr->len        = PACKET_remaining(pkt);

            
            if ((hdr->len % 4) != 0)
                return 0;

            
            hdr->partial    = 0;

            
            hdr->pn_len             = 0;
            hdr->spin_bit           = 0;
            hdr->key_phase          = 0;
            hdr->token              = NULL;
            hdr->token_len          = 0;
            memset(hdr->pn, 0, sizeof(hdr->pn));

            if (!PACKET_forward(pkt, hdr->len))
                return 0;
        } else if (version != QUIC_VERSION_1) {
            
            return 0;
        } else {
            if (l < QUIC_MIN_VALID_PKT_LEN_CRYPTO)
                return 0;

            
            raw_type = ((b0 >> 4) & 0x3);

            switch (raw_type) {
            case 0:
                hdr->type = QUIC_PKT_TYPE_INITIAL;
                break;
            case 1:
                hdr->type = QUIC_PKT_TYPE_0RTT;
                break;
            case 2:
                hdr->type = QUIC_PKT_TYPE_HANDSHAKE;
                break;
            case 3:
                hdr->type = QUIC_PKT_TYPE_RETRY;
                break;
            }

            hdr->pn_len     = 0;
            hdr->fixed      = 1;

            
            hdr->spin_bit   = 0;
            hdr->key_phase  = 0;

            if (hdr->type == QUIC_PKT_TYPE_INITIAL) {
                
                uint64_t token_len;

                if (!PACKET_get_quic_vlint(pkt, &token_len)
                    || token_len > SIZE_MAX
                    || !PACKET_get_bytes(pkt, &hdr->token, (size_t)token_len))
                    return 0;

                hdr->token_len  = (size_t)token_len;
                if (token_len == 0)
                    hdr->token = NULL;
            } else {
                hdr->token      = NULL;
                hdr->token_len  = 0;
            }

            if (hdr->type == QUIC_PKT_TYPE_RETRY) {
                
                hdr->data       = PACKET_data(pkt);
                hdr->len        = PACKET_remaining(pkt);

                
                hdr->partial    = 0;

                
                hdr->unused     = b0 & 0x0f;

                
                memset(hdr->pn, 0, sizeof(hdr->pn));

                if (!PACKET_forward(pkt, hdr->len))
                    return 0;
            } else {
                
                uint64_t len;

                hdr->pn_len     = partial ? 0 : ((b0 & 0x03) + 1);
                hdr->reserved   = partial ? 0 : ((b0 & 0x0C) >> 2);

                if (!PACKET_get_quic_vlint(pkt, &len)
                        || len < sizeof(hdr->pn))
                    return 0;

                if (!nodata && len > PACKET_remaining(pkt))
                    return 0;

                
                pn = (unsigned char *)PACKET_data(pkt);
                memset(hdr->pn, 0, sizeof(hdr->pn));
                if (partial) {
                    if (!PACKET_forward(pkt, sizeof(hdr->pn)))
                        return 0;

                    hdr->len = (size_t)(len - sizeof(hdr->pn));
                } else {
                    if (!PACKET_copy_bytes(pkt, hdr->pn, hdr->pn_len))
                        return 0;

                    hdr->len = (size_t)(len - hdr->pn_len);
                }

                if (nodata) {
                    hdr->data = NULL;
                } else {
                    hdr->data = PACKET_data(pkt);

                    
                    if (!PACKET_forward(pkt, hdr->len))
                        return 0;
                }
            }
        }
    }

    if (ptrs != NULL) {
        ptrs->raw_pn = pn;
        if (pn != NULL) {
            ptrs->raw_sample        = pn + 4;
            ptrs->raw_sample_len    = PACKET_end(pkt) - ptrs->raw_sample;
        }
    }

    return 1;
}

int ossl_quic_wire_encode_pkt_hdr(WPACKET *pkt,
                                  size_t short_conn_id_len,
                                  const QUIC_PKT_HDR *hdr,
                                  QUIC_PKT_HDR_PTRS *ptrs)
{
    unsigned char b0;
    size_t off_start, off_sample, off_pn;
    unsigned char *start = WPACKET_get_curr(pkt);

    if (!WPACKET_get_total_written(pkt, &off_start))
        return 0;

    if (ptrs != NULL) {
        
        if (!ossl_assert(pkt->staticbuf != NULL))
            return 0;
        ptrs->raw_start         = NULL;
        ptrs->raw_sample        = NULL;
        ptrs->raw_sample_len    = 0;
        ptrs->raw_pn            = 0;
    }

    
    if (hdr->partial
        || (hdr->type == QUIC_PKT_TYPE_1RTT
            && hdr->dst_conn_id.id_len != short_conn_id_len))
        return 0;

    if (hdr->type == QUIC_PKT_TYPE_1RTT) {
        

        
        if (hdr->dst_conn_id.id_len != short_conn_id_len
            || short_conn_id_len > QUIC_MAX_CONN_ID_LEN
            || hdr->pn_len < 1 || hdr->pn_len > 4)
            return 0;

        b0 = (hdr->spin_bit << 5)
             | (hdr->key_phase << 2)
             | (hdr->pn_len - 1)
             | (hdr->reserved << 3)
             | 0x40; 

        if (!WPACKET_put_bytes_u8(pkt, b0)
            || !WPACKET_memcpy(pkt, hdr->dst_conn_id.id, short_conn_id_len)
            || !WPACKET_get_total_written(pkt, &off_pn)
            || !WPACKET_memcpy(pkt, hdr->pn, hdr->pn_len))
            return 0;
    } else {
        
        unsigned int raw_type;

        if (hdr->dst_conn_id.id_len > QUIC_MAX_CONN_ID_LEN
            || hdr->src_conn_id.id_len > QUIC_MAX_CONN_ID_LEN)
            return 0;

        if (ossl_quic_pkt_type_has_pn(hdr->type)
            && (hdr->pn_len < 1 || hdr->pn_len > 4))
            return 0;

        switch (hdr->type) {
            case QUIC_PKT_TYPE_VERSION_NEG:
                if (hdr->version != 0)
                    return 0;

                
                raw_type = 0;
                break;

            case QUIC_PKT_TYPE_INITIAL:     raw_type = 0; break;
            case QUIC_PKT_TYPE_0RTT:        raw_type = 1; break;
            case QUIC_PKT_TYPE_HANDSHAKE:   raw_type = 2; break;
            case QUIC_PKT_TYPE_RETRY:       raw_type = 3; break;
            default:
                return 0;
        }

        b0 = (raw_type << 4) | 0x80; 
        if (hdr->type != QUIC_PKT_TYPE_VERSION_NEG || hdr->fixed)
            b0 |= 0x40; 
        if (ossl_quic_pkt_type_has_pn(hdr->type)) {
            b0 |= hdr->pn_len - 1;
            b0 |= (hdr->reserved << 2);
        }
        if (hdr->type == QUIC_PKT_TYPE_RETRY)
            b0 |= hdr->unused;

        if (!WPACKET_put_bytes_u8(pkt, b0)
            || !WPACKET_put_bytes_u32(pkt, hdr->version)
            || !WPACKET_put_bytes_u8(pkt, hdr->dst_conn_id.id_len)
            || !WPACKET_memcpy(pkt, hdr->dst_conn_id.id,
                               hdr->dst_conn_id.id_len)
            || !WPACKET_put_bytes_u8(pkt, hdr->src_conn_id.id_len)
            || !WPACKET_memcpy(pkt, hdr->src_conn_id.id,
                               hdr->src_conn_id.id_len))
            return 0;

        if (hdr->type == QUIC_PKT_TYPE_VERSION_NEG
            || hdr->type == QUIC_PKT_TYPE_RETRY) {
            if (hdr->len > 0 && !WPACKET_reserve_bytes(pkt, hdr->len, NULL))
                return 0;

            return 1;
        }

        if (hdr->type == QUIC_PKT_TYPE_INITIAL) {
            if (!WPACKET_quic_write_vlint(pkt, hdr->token_len)
                || !WPACKET_memcpy(pkt, hdr->token, hdr->token_len))
                return 0;
        }

        if (!WPACKET_quic_write_vlint(pkt, hdr->len + hdr->pn_len)
            || !WPACKET_get_total_written(pkt, &off_pn)
            || !WPACKET_memcpy(pkt, hdr->pn, hdr->pn_len))
            return 0;
    }

    if (hdr->len > 0 && !WPACKET_reserve_bytes(pkt, hdr->len, NULL))
        return 0;

    off_sample = off_pn + 4;

    if (ptrs != NULL) {
        ptrs->raw_start         = start;
        ptrs->raw_sample        = start + (off_sample - off_start);
        ptrs->raw_sample_len
            = WPACKET_get_curr(pkt) + hdr->len - ptrs->raw_sample;
        ptrs->raw_pn            = start + (off_pn - off_start);
    }

    return 1;
}

int ossl_quic_wire_get_encoded_pkt_hdr_len(size_t short_conn_id_len,
                                           const QUIC_PKT_HDR *hdr)
{
    size_t len = 0, enclen;

    
    if (hdr->partial
        || (hdr->type == QUIC_PKT_TYPE_1RTT
            && hdr->dst_conn_id.id_len != short_conn_id_len))
        return 0;

    if (hdr->type == QUIC_PKT_TYPE_1RTT) {
        

        
        if (hdr->dst_conn_id.id_len != short_conn_id_len
            || short_conn_id_len > QUIC_MAX_CONN_ID_LEN
            || hdr->pn_len < 1 || hdr->pn_len > 4)
            return 0;

        return 1 + short_conn_id_len + hdr->pn_len;
    } else {
        
        if (hdr->dst_conn_id.id_len > QUIC_MAX_CONN_ID_LEN
            || hdr->src_conn_id.id_len > QUIC_MAX_CONN_ID_LEN)
            return 0;

        len += 1  + 4 
            + 1 + hdr->dst_conn_id.id_len 
            + 1 + hdr->src_conn_id.id_len 
            ;

        if (ossl_quic_pkt_type_has_pn(hdr->type)) {
            if (hdr->pn_len < 1 || hdr->pn_len > 4)
                return 0;

            len += hdr->pn_len;
        }

        if (hdr->type == QUIC_PKT_TYPE_INITIAL) {
            enclen = ossl_quic_vlint_encode_len(hdr->token_len);
            if (!enclen)
                return 0;

            len += enclen + hdr->token_len;
        }

        if (!ossl_quic_pkt_type_must_be_last(hdr->type)) {
            enclen = ossl_quic_vlint_encode_len(hdr->len + hdr->pn_len);
            if (!enclen)
                return 0;

            len += enclen;
        }

        return len;
    }
}

int ossl_quic_wire_get_pkt_hdr_dst_conn_id(const unsigned char *buf,
                                           size_t buf_len,
                                           size_t short_conn_id_len,
                                           QUIC_CONN_ID *dst_conn_id)
{
    unsigned char b0;
    size_t blen;

    if (buf_len < QUIC_MIN_VALID_PKT_LEN
        || short_conn_id_len > QUIC_MAX_CONN_ID_LEN)
        return 0;

    b0 = buf[0];
    if ((b0 & 0x80) != 0) {
        

        
        if ((buf[1] || buf[2] || buf[3] || buf[4]) && (b0 & 0x40) == 0)
            return 0;

        blen = (size_t)buf[5]; 
        if (blen > QUIC_MAX_CONN_ID_LEN
            || buf_len < QUIC_MIN_VALID_PKT_LEN + blen)
            return 0;

        dst_conn_id->id_len = (unsigned char)blen;
        memcpy(dst_conn_id->id, buf + 6, blen);
        return 1;
    } else {
        
        if ((b0 & 0x40) == 0)
            
            return 0;

        if (buf_len < QUIC_MIN_VALID_PKT_LEN_CRYPTO + short_conn_id_len)
            return 0;

        dst_conn_id->id_len = (unsigned char)short_conn_id_len;
        memcpy(dst_conn_id->id, buf + 1, short_conn_id_len);
        return 1;
    }
}

int ossl_quic_wire_decode_pkt_hdr_pn(const unsigned char *enc_pn,
                                     size_t enc_pn_len,
                                     QUIC_PN largest_pn,
                                     QUIC_PN *res_pn)
{
    int64_t expected_pn, truncated_pn, candidate_pn, pn_win, pn_hwin, pn_mask;

    switch (enc_pn_len) {
        case 1:
            truncated_pn = enc_pn[0];
            break;
        case 2:
            truncated_pn = ((QUIC_PN)enc_pn[0] << 8)
                         |  (QUIC_PN)enc_pn[1];
            break;
        case 3:
            truncated_pn = ((QUIC_PN)enc_pn[0] << 16)
                         | ((QUIC_PN)enc_pn[1] << 8)
                         |  (QUIC_PN)enc_pn[2];
            break;
        case 4:
            truncated_pn = ((QUIC_PN)enc_pn[0] << 24)
                         | ((QUIC_PN)enc_pn[1] << 16)
                         | ((QUIC_PN)enc_pn[2] << 8)
                         |  (QUIC_PN)enc_pn[3];
            break;
        default:
            return 0;
    }

    
    expected_pn     = largest_pn + 1;
    pn_win          = ((int64_t)1) << (enc_pn_len * 8);
    pn_hwin         = pn_win / 2;
    pn_mask         = pn_win - 1;
    candidate_pn    = (expected_pn & ~pn_mask) | truncated_pn;
    if (candidate_pn <= expected_pn - pn_hwin
        && candidate_pn < (((int64_t)1) << 62) - pn_win)
        *res_pn = candidate_pn + pn_win;
    else if (candidate_pn > expected_pn + pn_hwin
             && candidate_pn >= pn_win)
        *res_pn = candidate_pn - pn_win;
    else
        *res_pn = candidate_pn;
    return 1;
}


int ossl_quic_wire_determine_pn_len(QUIC_PN pn,
                                    QUIC_PN largest_acked)
{
    uint64_t num_unacked
        = (largest_acked == QUIC_PN_INVALID) ? pn + 1 : pn - largest_acked;

    

    if (num_unacked <= (1U<<7))  return 1;
    if (num_unacked <= (1U<<15)) return 2;
    if (num_unacked <= (1U<<23)) return 3;
    return 4;
}

int ossl_quic_wire_encode_pkt_hdr_pn(QUIC_PN pn,
                                     unsigned char *enc_pn,
                                     size_t enc_pn_len)
{
    switch (enc_pn_len) {
        case 1:
            enc_pn[0] = (unsigned char)pn;
            break;
        case 2:
            enc_pn[1] = (unsigned char)pn;
            enc_pn[0] = (unsigned char)(pn >> 8);
            break;
        case 3:
            enc_pn[2] = (unsigned char)pn;
            enc_pn[1] = (unsigned char)(pn >> 8);
            enc_pn[0] = (unsigned char)(pn >> 16);
            break;
        case 4:
            enc_pn[3] = (unsigned char)pn;
            enc_pn[2] = (unsigned char)(pn >> 8);
            enc_pn[1] = (unsigned char)(pn >> 16);
            enc_pn[0] = (unsigned char)(pn >> 24);
            break;
        default:
            return 0;
    }

    return 1;
}

int ossl_quic_validate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
                                           const char *propq,
                                           const QUIC_PKT_HDR *hdr,
                                           const QUIC_CONN_ID *client_initial_dcid)
{
    unsigned char expected_tag[QUIC_RETRY_INTEGRITY_TAG_LEN];
    const unsigned char *actual_tag;

    if (hdr == NULL || hdr->len < QUIC_RETRY_INTEGRITY_TAG_LEN)
        return 0;

    if (!ossl_quic_calculate_retry_integrity_tag(libctx, propq,
                                                 hdr, client_initial_dcid,
                                                 expected_tag))
        return 0;

    actual_tag = hdr->data + hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN;

    return !CRYPTO_memcmp(expected_tag, actual_tag,
                          QUIC_RETRY_INTEGRITY_TAG_LEN);
}


static const unsigned char retry_integrity_key[] = {
    0xbe, 0x0c, 0x69, 0x0b, 0x9f, 0x66, 0x57, 0x5a,
    0x1d, 0x76, 0x6b, 0x54, 0xe3, 0x68, 0xc8, 0x4e
};

static const unsigned char retry_integrity_nonce[] = {
    0x46, 0x15, 0x99, 0xd3, 0x5d, 0x63, 0x2b, 0xf2,
    0x23, 0x98, 0x25, 0xbb
};

int ossl_quic_calculate_retry_integrity_tag(OSSL_LIB_CTX *libctx,
                                            const char *propq,
                                            const QUIC_PKT_HDR *hdr,
                                            const QUIC_CONN_ID *client_initial_dcid,
                                            unsigned char *tag)
{
    EVP_CIPHER *cipher = NULL;
    EVP_CIPHER_CTX *cctx = NULL;
    int ok = 0, l = 0, l2 = 0, wpkt_valid = 0;
    WPACKET wpkt;
    
    unsigned char buf[128];
    QUIC_PKT_HDR hdr2;
    size_t hdr_enc_len = 0;

    if (hdr->type != QUIC_PKT_TYPE_RETRY || hdr->version == 0
        || hdr->len < QUIC_RETRY_INTEGRITY_TAG_LEN
        || hdr->data == NULL
        || client_initial_dcid == NULL || tag == NULL
        || client_initial_dcid->id_len > QUIC_MAX_CONN_ID_LEN) {
        ERR_raise(ERR_LIB_SSL, ERR_R_PASSED_INVALID_ARGUMENT);
        goto err;
    }

    
    hdr2 = *hdr;
    hdr2.len = 0;

    
    if (!WPACKET_init_static_len(&wpkt, buf, sizeof(buf), 0)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
        goto err;
    }

    wpkt_valid = 1;

    
    if (!WPACKET_put_bytes_u8(&wpkt, client_initial_dcid->id_len)
        || !WPACKET_memcpy(&wpkt, client_initial_dcid->id,
                           client_initial_dcid->id_len)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
        goto err;
    }

    
    if (!ossl_quic_wire_encode_pkt_hdr(&wpkt, hdr2.dst_conn_id.id_len,
                                       &hdr2, NULL))
        goto err;

    if (!WPACKET_get_total_written(&wpkt, &hdr_enc_len)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_CRYPTO_LIB);
        return 0;
    }

    
    
    if ((cipher = EVP_CIPHER_fetch(libctx, "AES-128-GCM", propq)) == NULL) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        goto err;
    }

    if ((cctx = EVP_CIPHER_CTX_new()) == NULL) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        goto err;
    }

    if (!EVP_CipherInit_ex(cctx, cipher, NULL,
                           retry_integrity_key, retry_integrity_nonce, 1)) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        goto err;
    }

    
    if (EVP_CipherUpdate(cctx, NULL, &l, buf, hdr_enc_len) != 1) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        return 0;
    }

    
    if (EVP_CipherUpdate(cctx, NULL, &l, hdr->data,
                         hdr->len - QUIC_RETRY_INTEGRITY_TAG_LEN) != 1) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        return 0;
    }

    
    if (EVP_CipherFinal_ex(cctx, NULL, &l2) != 1) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        return 0;
    }

    if (EVP_CIPHER_CTX_ctrl(cctx, EVP_CTRL_AEAD_GET_TAG,
                            QUIC_RETRY_INTEGRITY_TAG_LEN,
                            tag) != 1) {
        ERR_raise(ERR_LIB_SSL, ERR_R_EVP_LIB);
        return 0;
    }

    ok = 1;
err:
    EVP_CIPHER_free(cipher);
    EVP_CIPHER_CTX_free(cctx);
    if (wpkt_valid)
        WPACKET_finish(&wpkt);

    return ok;
}
