decode.c

Go to the documentation of this file.

/*
 *   This library is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU Lesser General Public
 *   License as published by the Free Software Foundation; either
 *   version 2.1 of the License, or (at your option) any later version.
 *
 *   This library is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
 *   Lesser General Public License for more details.
 *
 *   You should have received a copy of the GNU Lesser General Public
 *   License along with this library; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */
 
/**
 * $Id: c70875a6d29fa55196fca148a04e28bef48c74ce $
 *
 * @file src/lib/util/decode.c
 * @brief Generic functions for decoding protocols.
 *
 * @copyright 2022 Network RADIUS SAS (legal@networkradius.com)
 */
#include <freeradius-devel/io/test_point.h>
#include <freeradius-devel/util/proto.h>
#include <freeradius-devel/util/decode.h>
 
/** Decode an array of values from the network
 *
 * @param[in] ctx context       to alloc new attributes in.
 * @param[out] out              Where to write the decoded #fr_pair_t
 * @param[in] parent            dictionary entry, must have parent->flags.array set
 * @param[in] data              to parse.
 * @param[in] data_len          of data to parse.
 * @param[in] decode_ctx        passed to decode_value
 * @param[in] decode_value      function to decode one value.
 *      <0 on error - decode error, or OOM
 *      data_len on success
 */
ssize_t fr_pair_array_from_network(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_attr_t const *parent,
                                   uint8_t const *data, size_t data_len,
                                   void *decode_ctx, fr_pair_decode_value_t decode_value)
{
        uint8_t const           *p = data, *end = p + data_len;
        ssize_t                 slen;
        fr_pair_list_t          list;
 
        fr_pair_list_init(&list);
 
        FR_PROTO_HEX_DUMP(data, data_len, "fr_pair_array_from_network");
 
        if (!fr_cond_assert_msg(parent->flags.array,
                                "%s: Internal sanity check failed, attribute \"%s\" does not have array bit set",
                                __FUNCTION__, parent->name)) return PAIR_DECODE_FATAL_ERROR;
 
        /*
         *      Catch stupidities.
         */
        if (data_len == 0) return data_len;
 
        while (p < end) {
                slen = decode_value(ctx, &list, parent, p, (end - p), decode_ctx);
                if (slen <= 0) {
                        fr_pair_list_free(&list);
                        return slen - (p - data);
                }
 
                p += slen;
        }
 
        fr_pair_list_append(out, &list);
        return data_len;
}
 
/** Create a "raw" pair from malformed network data
 *
 * @param[in] ctx context       to alloc new attributes in.
 * @param[out] out              Where to write the decoded #fr_pair_t
 * @param[in] da                dictionary entry which it should be
 * @param[in] data              to parse.
 * @param[in] data_len          of data to parse.
 *      <0 on error - decode error, or OOM
 *      data_len on success
 */
ssize_t fr_pair_raw_from_network(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_attr_t const *da,
                                 uint8_t const *data, size_t data_len)
{
        ssize_t slen;
        fr_pair_t *vp;
        fr_dict_attr_t *unknown;
        fr_dict_attr_t const *child;
 
#if defined(STATIC_ANALYZER) || !defined(NDEBUG)
        if (!da->parent) return -1; /* stupid static analyzers */
#endif
 
        FR_PROTO_TRACE("Creating Raw attribute %s", da->name);
        FR_PROTO_HEX_DUMP(data, data_len, "fr_pair_raw_from_network");
 
        /*
         *      Build an unknown attr of the entire data.
         */
        unknown = fr_dict_attr_unknown_raw_afrom_da(ctx, da);
        if (!unknown) return -1;
 
        vp = fr_pair_afrom_da(ctx, unknown); /* makes a copy of 'unknown' */
        child = unknown;
        fr_dict_attr_unknown_free(&child); /* const issues */
        if (!vp) return -1;
 
        /*
         *      Don't bother getting data from the network if there's no data.
         */
        if (data_len > 0) {
                slen = fr_value_box_from_network(vp, &vp->data, vp->da->type, vp->da,
                                                 &FR_DBUFF_TMP(data, data_len), data_len, true);
                if (slen < 0) {
                        talloc_free(vp);
                        return slen;
                }
        }
 
        /*
         *      Raw VPs are always tainted.
         */
        vp->vp_tainted = true;
        fr_pair_append(out, vp);
 
        return data_len;
}
 
 
/** Decode a list of pairs from the network
 *
 * @param[in] ctx context       to alloc new attributes in.
 * @param[out] out              Where to write the decoded #fr_pair_t
 * @param[in] parent            dictionary entry, must have parent->flags.array set
 * @param[in] data              to parse.
 * @param[in] data_len          of data to parse.
 * @param[in] decode_ctx        passed to decode_tlv
 * @param[in] decode_tlv        function to decode one attribute / option / tlv
 * @param[in] verify_tlvs       simple function to see if the TLVs are even vaguely well-formed
 * @param[in] nested            whether or not we create nested VPs.
 *      <0 on error - decode error, or OOM
 *      data_len on success
 *
 *  The decode_tlv function should return an error if the option is
 *  malformed.  In that case, the entire list of pairs is thrown away,
 *  and a "raw" attribute is created which contains the entire
 *  data_len.
 *
 *  If the value is malformed, then the decode_tlv function should call
 *  fr_pair_raw_from_network() on the value, and return a positive value.
 */
ssize_t fr_pair_tlvs_from_network(TALLOC_CTX *ctx, fr_pair_list_t *out,
                                  fr_dict_attr_t const *parent,
                                  uint8_t const *data, size_t const data_len,
                                  void *decode_ctx, fr_pair_decode_value_t decode_tlv,
                                  fr_pair_tlvs_verify_t verify_tlvs,
                                  bool nested)
{
        uint8_t const *p, *end;
        fr_pair_list_t tlvs, *list;
        fr_pair_t *vp = NULL;
        TALLOC_CTX *child_ctx;
 
        FR_PROTO_HEX_DUMP(data, data_len, "fr_pair_tlvs_from_network");
 
        switch (parent->type) {
        case FR_TYPE_TLV:
        case FR_TYPE_VENDOR:
        case FR_TYPE_STRUCT:
                break;
 
        default:
                fr_strerror_printf("Internal sanity check failed, attribute \"%s\" has unexpected data type '%s'",
                                   parent->name, fr_type_to_str(parent->type));
                return PAIR_DECODE_FATAL_ERROR;
        }
 
        /*
         *      Do a quick sanity check to see if the TLVs are at all OK.
         */
        if (verify_tlvs && !verify_tlvs(data, data_len)) return -1;
 
        p = data;
        end = data + data_len;
 
        if (!nested) {
                fr_pair_list_init(&tlvs);
                list = &tlvs;
                child_ctx = ctx;
        } else {
                vp = fr_pair_afrom_da(ctx, parent);
                if (!vp) return PAIR_DECODE_OOM;
                list = &vp->vp_group;
                child_ctx = vp;
        }
 
        while (p < end) {
                ssize_t slen;
 
                slen = decode_tlv(child_ctx, list, parent, p, (end - p), decode_ctx);
                if (slen <= 0) {
                        FR_PROTO_TRACE("    tlv decode failed at offset %zu - %s", (size_t) (p - data), fr_strerror());
                        fr_pair_list_free(list);
                        talloc_free(vp);
 
                        /*
                         *      Don't decode it as raw.  We don't know how the TLVs are structured, so the
                         *      only da we have is the parent.  The output has to in the parent with a child
                         *      da.  So if we create a raw attribute here, then we have the raw attribute of
                         *      da==parent going into the parent, which is wrong.
                         */
                        return PAIR_DECODE_FATAL_ERROR;
                }
 
                p += slen;
        }
 
        if (!nested) {
                fr_pair_list_append(out, &tlvs);
        } else {
                fr_pair_append(out, vp);
        }
 
        return data_len;
}
 
 
/** Decode a DNS label or a list of DNS labels from the network
 *
 * @param[in] ctx context       to alloc new attributes in.
 * @param[out] out              Where to write the decoded #fr_pair_t
 * @param[in] parent            dictionary entry, must have parent->flags.array set
 * @param[in] start             of the DNS labels to decode
 * @param[in] data              to parse.
 * @param[in] data_len          of data to parse.
 * @param[in] lb                struct to help with decoding packets.
 * @param[in] exact             whether the labels should entirely fill the buffer.
 * @return
 *      <0 on error - decode error, or OOM
 *      data_len on success
 *
 *  DNS labels exist in many protocols, and we also have src/lib/dns.c, so we might
 *  as well put a common function here, too.
 *
 *  This function assumes that the DNS label or labels take up all of the
 *  input.  If they do not, then the decoded DNS labels are freed, and
 *  a raw attribute is returned instead.
 */
ssize_t fr_pair_dns_labels_from_network(TALLOC_CTX *ctx, fr_pair_list_t *out,
                                        fr_dict_attr_t const *parent, uint8_t const *start,
                                        uint8_t const *data, size_t const data_len, fr_dns_labels_t *lb, bool exact)
{
        ssize_t slen;
        size_t total, labels_len;
        fr_pair_t *vp;
        uint8_t const *next = data;
        fr_pair_list_t tmp;
 
        FR_PROTO_HEX_DUMP(data, data_len, "fr_pair_dns_labels_from_network");
 
        fr_pair_list_init(&tmp);
 
        /*
         *      This function handles both single-valued and array
         *      types.  It's just easier that way.
         */
        if (!parent->flags.array) {
                /*
                 *      Decode starting at "NEXT", but allowing decodes from the start of the packet.
                 */
                slen = fr_dns_label_uncompressed_length(start, data, data_len, &next, lb);
                if (slen <= 0) {
                        FR_PROTO_TRACE("ERROR - uncompressed length failed");
                        goto raw;
                }
 
                labels_len = next - data; /* decode only what we've found */
        } else {
                /*
                 *      Get the length of the entire set of labels, up
                 *      to (and including) the final 0x00.
                 *
                 *      If any of the labels point outside of this
                 *      area, OR they are otherwise invalid, then that's an error.
                 */
                slen = fr_dns_labels_network_verify(start, data, data_len, data, lb);
                if (slen <= 0) {
                        FR_PROTO_TRACE("ERROR - network verify failed");
                        goto raw;
                }
 
                labels_len = slen;
        }
 
        /*
         *      The labels MUST fill the entire buffer.
         */
        if (exact && (labels_len != data_len)) {
                FR_PROTO_TRACE("ERROR - labels_len %zu != data_len %zu", labels_len, data_len);
        raw:
                return fr_pair_raw_from_network(ctx, out, parent, data, data_len);
        }
 
        /*
         *      Loop over the input buffer, decoding the labels one by
         *      one.
         *
         *      @todo - put the labels into a child cursor, and then
         *      merge them only if it succeeds.  That doesn't seem to
         *      work for some reason, and I don't have time to debug
         *      it right now.  So... let's leave it.
         */
        for (total = 0; total < labels_len; total += slen) {
                vp = fr_pair_afrom_da(ctx, parent);
                if (!vp) return PAIR_DECODE_OOM;
 
                /*
                 *      Having verified the input above, this next
                 *      function should never fail unless there's a
                 *      bug in the code.
                 */
                slen = fr_dns_label_to_value_box(vp, &vp->data, data, labels_len, data + total, true, lb);
                if (slen <= 0) {
                        FR_PROTO_TRACE("ERROR - failed decoding DNS label at with %zu error %zd", total, slen);
                        talloc_free(vp);
                        fr_pair_list_free(&tmp);
                        goto raw;
                }
 
                fr_pair_append(&tmp, vp);
        }
 
        fr_pair_list_append(out, &tmp);
        return labels_len;
}
 
/** Generic decode value.
 *
 */
ssize_t fr_pair_decode_value(TALLOC_CTX *ctx, fr_pair_list_t *out, fr_dict_attr_t const *parent,
                             uint8_t const *data, size_t const data_len, UNUSED void *decode_ctx)
{
        fr_pair_t *vp;
        ssize_t slen;
 
        if (!fr_type_is_leaf(parent->type)) {
                FR_PROTO_TRACE("Cannot use generic decoder for data type %s", fr_type_to_str(parent->type));
                fr_strerror_printf("Cannot decode data type %s", fr_type_to_str(parent->type));
                return -1;
        }
 
        vp = fr_pair_afrom_da(ctx, parent);
        if (!vp) return PAIR_DECODE_OOM;
 
        /*
         *      No protocol-specific data types here.
         *
         *      If we can't decode this field, then the entire
         *      structure is treated as a raw blob.
         */
        slen = fr_value_box_from_network(vp, &vp->data, vp->vp_type, vp->da,
                                          &FR_DBUFF_TMP(data, data_len), data_len, true);
        if (slen <= 0) {
                FR_PROTO_TRACE("failed decoding child VP %s", vp->da->name);
                talloc_free(vp);
                return fr_pair_raw_from_network(ctx, out, parent, data, data_len);
        }
 
        fr_pair_append(out, vp);
 
        return slen;
}