NAS/NASHelperNGAP_SecurityModeCommand.cpp at main · melrosenetworks/NAS · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
#include "NASHelperNGAP.hpp"

namespace {

bool securityModeCommandOptionalIsTlvE(std::uint8_t iei) {
    return iei == 0x78U;
}

bool securityModeCommandOptionalIsTlv(std::uint8_t iei) {
    switch (iei) {
        case 0x36:
        case 0x38:
        case 0x19:
        case 0x55:
            return true;
        default:
            return false;
    }
}

bool securityModeCommandOptionalTv1HighNibble(std::uint8_t firstOctet) {
    return (firstOctet >> 4U) == 14U;
}

}  // namespace

bool NASHelperNGAP::tryParseSecurityModeCommandInformationElements(const std::uint8_t* const informationElements,
                                                                   const std::size_t informationElementOctetCount,
                                                                   SecurityModeCommandInformationElementsParse& out) {
    out = SecurityModeCommandInformationElementsParse{};

    if (informationElements == nullptr || informationElementOctetCount < 3U) {
        return false;
    }

    const std::uint8_t nasAlg = informationElements[0];
    const std::uint8_t ngKsiSpare = informationElements[1];
    const std::uint8_t capLen = informationElements[2];

    if (capLen < 2U || capLen > 8U) {
        return false;
    }

    const std::size_t mandatoryTotal = 2U + 1U + static_cast<std::size_t>(capLen);
    if (informationElementOctetCount < mandatoryTotal) {
        return false;
    }

    out.mandatory.selected_nas_security_algorithms_octet = nasAlg;
    out.mandatory.ngksi_and_spare_octet = ngKsiSpare;
    out.mandatory.replayed_ue_security_capabilities_value = informationElements + 3U;
    out.mandatory.replayed_ue_security_capabilities_value_octet_count = static_cast<std::size_t>(capLen);
    out.mandatory.mandatory_total_octets = mandatoryTotal;

    std::size_t i = mandatoryTotal;
    while (i < informationElementOctetCount) {
        const std::uint8_t b = informationElements[i];

        if (securityModeCommandOptionalIsTlvE(b)) {
            if (i + 3U > informationElementOctetCount) {
                break;
            }
            const std::uint16_t len =
                static_cast<std::uint16_t>((static_cast<unsigned>(informationElements[i + 1]) << 8U) |
                                           static_cast<unsigned>(informationElements[i + 2]));
            const std::size_t chunk = 3U + static_cast<std::size_t>(len);
            if (i + chunk > informationElementOctetCount || i + chunk < i) {
                break;
            }
            SecurityModeCommandOptionalInformationElement opt{};
            opt.iei = b;
            opt.encoding = SecurityModeCommandOptionalInformationElement::Encoding::TlvE;
            opt.value.assign(informationElements + i + 3, informationElements + i + 3 + len);
            out.optionals.push_back(std::move(opt));
            i += chunk;
            continue;
        }

        if (b == 0x57U) {
            if (i + 2U > informationElementOctetCount) {
                break;
            }
            SecurityModeCommandOptionalInformationElement opt{};
            opt.iei = b;
            opt.encoding = SecurityModeCommandOptionalInformationElement::Encoding::Tv2;
            opt.tv2_value_octet = informationElements[i + 1U];
            out.optionals.push_back(std::move(opt));
            i += 2U;
            continue;
        }

        if (securityModeCommandOptionalTv1HighNibble(b)) {
            SecurityModeCommandOptionalInformationElement opt{};
            opt.iei = static_cast<std::uint8_t>(b >> 4U);
            opt.encoding = SecurityModeCommandOptionalInformationElement::Encoding::Tv1;
            opt.tv1_octet = b;
            out.optionals.push_back(std::move(opt));
            i += 1U;
            continue;
        }

        if (securityModeCommandOptionalIsTlv(b)) {
            if (i + 2U > informationElementOctetCount) {
                break;
            }
            const std::uint8_t len = informationElements[i + 1];
            const std::size_t chunk = 2U + static_cast<std::size_t>(len);
            if (i + chunk > informationElementOctetCount || i + chunk < i) {
                break;
            }
            SecurityModeCommandOptionalInformationElement opt{};
            opt.iei = b;
            opt.encoding = SecurityModeCommandOptionalInformationElement::Encoding::Tlv;
            opt.value.assign(informationElements + i + 2, informationElements + i + 2 + len);
            out.optionals.push_back(std::move(opt));
            i += chunk;
            continue;
        }

        out.unparsed_begin = informationElements + i;
        out.unparsed_octet_count = informationElementOctetCount - i;
        break;
    }

    out.ok = true;
    return true;
}