← Back to branch summary

~ubuntu-branches/ubuntu/wily/net-snmp/wily-proposed

« back to all changes in this revision

Viewing changes to .pc/CVE-2014-2285.patch/perl/TrapReceiver/TrapReceiver.xs

  • Committer: Package Import Robot
  • Author(s): Marc Deslauriers
  • Date: 2014-04-08 08:17:14 UTC
  • Revision ID: package-import@ubuntu.com-20140408081714-31du0g3p3ggkwe9o
Tags: 5.7.2~dfsg-8.1ubuntu3
* SECURITY UPDATE: denial of service via AgentX subagent timeout
  - debian/patches/CVE-2012-6151.patch: track cancelled sessions in
    agent/mibgroup/agentx/{master.c,master_admin.c}, agent/snmp_agent.c,
    include/net-snmp/agent/snmp_agent.h.
  - CVE-2012-6151
* SECURITY UPDATE: denial of service when ICMP-MIB is in use
  - debian/patches/CVE-2014-2284.patch: fix ICMP mib table handling in
    agent/mibgroup/mibII/icmp.c, agent/mibgroup/mibII/kernel_linux.*.
  - CVE-2014-2284
* SECURITY UPDATE: denial of service in perl trap handler
  - debian/patches/CVE-2014-2285.patch: handle empty community string in
    perl/TrapReceiver/TrapReceiver.xs.
  - CVE-2014-2285

Show diffs side-by-side

added added

removed removed

Lines of Context:
.pc/CVE-2014-2285.patch/perl/TrapReceiver/TrapReceiver.xs
 
1
/* -*- c -*- */
 
2
#if defined(_WIN32) && !defined(_WIN32_WINNT)
 
3
#define _WIN32_WINNT 0x501
 
4
#endif
 
5
 
 
6
#include "EXTERN.h"
 
7
#include "perl.h"
 
8
#include "XSUB.h"
 
9
 
 
10
#include "ppport.h"
 
11
 
 
12
#include <net-snmp/net-snmp-config.h>
 
13
#include <net-snmp/net-snmp-includes.h>
 
14
#include <net-snmp/agent/net-snmp-agent-includes.h>
 
15
 
 
16
#include "perl_snmptrapd.h"
 
17
 
 
18
#include "const-c.inc"
 
19
 
 
20
typedef struct trapd_cb_data_s {
 
21
   SV *perl_cb;
 
22
} trapd_cb_data;
 
23
 
 
24
typedef struct netsnmp_oid_s {
 
25
    oid                 *name;
 
26
    size_t               len;
 
27
    oid                  namebuf[ MAX_OID_LEN ];
 
28
} netsnmp_oid;
 
29
 
 
30
int   perl_trapd_handler( netsnmp_pdu           *pdu,
 
31
                          netsnmp_transport     *transport,
 
32
                          netsnmp_trapd_handler *handler)
 
33
{
 
34
    trapd_cb_data *cb_data;
 
35
    SV *pcallback;
 
36
    netsnmp_variable_list *vb;
 
37
    netsnmp_oid *o;
 
38
    SV **tmparray;
 
39
    int i, c = 0;
 
40
    u_char *outbuf;
 
41
    size_t ob_len = 0, oo_len = 0;
 
42
    AV *varbinds;
 
43
    HV *pduinfo;
 
44
    int noValuesReturned;
 
45
    int callingCFfailed = 0;
 
46
    int result = NETSNMPTRAPD_HANDLER_OK;
 
47
    netsnmp_pdu * v2pdu = NULL;
 
48
 
 
49
    dSP;
 
50
    ENTER;
 
51
    SAVETMPS;
 
52
 
 
53
    if (!pdu || !handler)
 
54
        return 0;
 
55
 
 
56
    /* nuke v1 PDUs */
 
57
    if (pdu->command == SNMP_MSG_TRAP) {
 
58
        v2pdu = convert_v1pdu_to_v2(pdu);
 
59
        pdu = v2pdu;
 
60
    }
 
61
 
 
62
    cb_data = handler->handler_data;
 
63
    if (!cb_data || !cb_data->perl_cb)
 
64
        return 0;
 
65
 
 
66
    pcallback = cb_data->perl_cb;
 
67
 
 
68
    /* get PDU related info */
 
69
    pduinfo = newHV();
 
70
#define STOREPDU(n, v) (void)hv_store(pduinfo, n, strlen(n), v, 0)
 
71
#define STOREPDUi(n, v) STOREPDU(n, newSViv(v))
 
72
#define STOREPDUs(n, v) STOREPDU(n, newSVpv(v, 0))
 
73
    STOREPDUi("version", pdu->version);
 
74
    STOREPDUs("notificationtype", ((pdu->command == SNMP_MSG_INFORM) ? "INFORM":"TRAP"));
 
75
    STOREPDUi("requestid", pdu->reqid);
 
76
    STOREPDUi("messageid", pdu->msgid);
 
77
    STOREPDUi("transactionid", pdu->transid);
 
78
    STOREPDUi("errorstatus", pdu->errstat);
 
79
    STOREPDUi("errorindex", pdu->errindex);
 
80
    if (pdu->version == 3) {
 
81
        STOREPDUi("securitymodel", pdu->securityModel);
 
82
        STOREPDUi("securitylevel", pdu->securityLevel);
 
83
        STOREPDU("contextName",
 
84
                 newSVpv(pdu->contextName, pdu->contextNameLen));
 
85
        STOREPDU("contextEngineID",
 
86
                 newSVpv((char *) pdu->contextEngineID,
 
87
                                    pdu->contextEngineIDLen));
 
88
        STOREPDU("securityEngineID",
 
89
                 newSVpv((char *) pdu->securityEngineID,
 
90
                                    pdu->securityEngineIDLen));
 
91
        STOREPDU("securityName",
 
92
                 newSVpv((char *) pdu->securityName, pdu->securityNameLen));
 
93
    } else {
 
94
        STOREPDU("community",
 
95
                 newSVpv((char *) pdu->community, pdu->community_len));
 
96
    }
 
97
 
 
98
    if (transport && transport->f_fmtaddr) {
 
99
        char *tstr = transport->f_fmtaddr(transport, pdu->transport_data,
 
100
                                          pdu->transport_data_length);
 
101
        STOREPDUs("receivedfrom", tstr);
 
102
        netsnmp_free(tstr);
 
103
    }
 
104
 
 
105
 
 
106
    /*
 
107
     * collect OID objects in a temp array first
 
108
     */
 
109
    /* get VARBIND related info */
 
110
    i = count_varbinds(pdu->variables);
 
111
    tmparray = malloc(sizeof(*tmparray) * i);
 
112
 
 
113
    for(vb = pdu->variables; vb; vb = vb->next_variable) {
 
114
 
 
115
        /* get the oid */
 
116
        o = malloc(sizeof(netsnmp_oid));
 
117
        o->name = o->namebuf;
 
118
        o->len = vb->name_length;
 
119
        memcpy(o->name, vb->name, vb->name_length * sizeof(oid));
 
120
 
 
121
#undef CALL_EXTERNAL_OID_NEW
 
122
 
 
123
#ifdef CALL_EXTERNAL_OID_NEW
 
124
        {
 
125
        SV *arg;
 
126
        SV *rarg;
 
127
 
 
128
        PUSHMARK(sp);
 
129
 
 
130
        rarg = sv_2mortal(newSViv((IV) 0));
 
131
        arg = sv_2mortal(newSVrv(rarg, "netsnmp_oidPtr"));
 
132
        sv_setiv(arg, (IV) o);
 
133
        XPUSHs(rarg);
 
134
 
 
135
        PUTBACK;
 
136
        i = perl_call_pv("NetSNMP::OID::newwithptr", G_SCALAR);
 
137
        SPAGAIN;
 
138
 
 
139
        if (i != 1) {
 
140
            snmp_log(LOG_ERR, "unhandled OID error.\n");
 
141
            /* ack XXX */
 
142
        }
 
143
        /* get the value */
 
144
        tmparray[c++] = POPs;
 
145
        SvREFCNT_inc(tmparray[c-1]);
 
146
        PUTBACK;
 
147
        }
 
148
#else /* build it and bless ourselves */
 
149
        {
 
150
            HV *hv = newHV();
 
151
            SV *rv = newRV_noinc((SV *) hv);
 
152
            SV *rvsub = newRV_noinc((SV *) newSViv((UV) o));
 
153
            rvsub = sv_bless(rvsub, gv_stashpv("netsnmp_oidPtr", 1));
 
154
            (void)hv_store(hv, "oidptr", 6,  rvsub, 0);
 
155
            rv = sv_bless(rv, gv_stashpv("NetSNMP::OID", 1));
 
156
            tmparray[c++] = rv;
 
157
        }
 
158
        
 
159
#endif /* build oid ourselves */
 
160
    }
 
161
 
 
162
    /*
 
163
     * build the varbind lists
 
164
     */
 
165
    varbinds = newAV();
 
166
    for(vb = pdu->variables, i = 0; vb; vb = vb->next_variable, i++) {
 
167
        /* push the oid */
 
168
        AV *vba;
 
169
        vba = newAV();
 
170
 
 
171
 
 
172
        /* get the value */
 
173
        outbuf = NULL;
 
174
        ob_len = 0;
 
175
        oo_len = 0;
 
176
        sprint_realloc_by_type(&outbuf, &ob_len, &oo_len, 1,
 
177
                               vb, 0, 0, 0);
 
178
 
 
179
        av_push(vba,tmparray[i]);
 
180
        av_push(vba,newSVpvn((char *) outbuf, oo_len));
 
181
        netsnmp_free(outbuf);
 
182
        av_push(vba,newSViv(vb->type));
 
183
        av_push(varbinds, (SV *) newRV_noinc((SV *) vba));
 
184
    }
 
185
 
 
186
    PUSHMARK(sp);
 
187
 
 
188
    /* store the collected information on the stack */
 
189
    XPUSHs(sv_2mortal(newRV_noinc((SV*) pduinfo)));
 
190
    XPUSHs(sv_2mortal(newRV_noinc((SV*) varbinds)));
 
191
 
 
192
    /* put the stack back in order */
 
193
    PUTBACK;
 
194
 
 
195
    /* actually call the callback function */
 
196
    if (SvTYPE(pcallback) == SVt_PVCV) {
 
197
        noValuesReturned = perl_call_sv(pcallback, G_SCALAR);
 
198
        /* XXX: it discards the results, which isn't right */
 
199
    } else if (SvROK(pcallback) && SvTYPE(SvRV(pcallback)) == SVt_PVCV) {
 
200
        /* reference to code */
 
201
        noValuesReturned = perl_call_sv(SvRV(pcallback), G_SCALAR);
 
202
    } else {
 
203
        snmp_log(LOG_ERR, " tried to call a perl function but failed to understand its type: (ref = %p, svrok: %lu, SVTYPE: %lu)\n", pcallback, (unsigned long)SvROK(pcallback), (unsigned long)SvTYPE(pcallback));
 
204
        callingCFfailed = 1;
 
205
    }
 
206
 
 
207
    if (!callingCFfailed) {
 
208
      SPAGAIN;
 
209
 
 
210
      if ( noValuesReturned == 0 ) {
 
211
        snmp_log(LOG_WARNING, " perl callback function %p did not return a scalar, assuming %d (NETSNMPTRAPD_HANDLER_OK)\n", pcallback, NETSNMPTRAPD_HANDLER_OK);
 
212
      }
 
213
      else {
 
214
        SV *rv = POPs;
 
215
 
 
216
        if (SvTYPE(rv) != SVt_IV) {
 
217
          snmp_log(LOG_WARNING, " perl callback function %p returned a scalar of type %lu instead of an integer, assuming %d (NETSNMPTRAPD_HANDLER_OK)\n", pcallback, (unsigned long)SvTYPE(rv), NETSNMPTRAPD_HANDLER_OK);
 
218
        }
 
219
        else {
 
220
          int rvi = (IV)SvIVx(rv);
 
221
 
 
222
          if ((NETSNMPTRAPD_HANDLER_OK <= rvi) && (rvi <= NETSNMPTRAPD_HANDLER_FINISH)) {
 
223
            snmp_log(LOG_DEBUG, " perl callback function %p returns %d\n", pcallback, rvi);
 
224
            result = rvi;
 
225
          }
 
226
          else {
 
227
            snmp_log(LOG_WARNING, " perl callback function %p returned an invalid scalar integer value (%d), assuming %d (NETSNMPTRAPD_HANDLER_OK)\n", pcallback, rvi, NETSNMPTRAPD_HANDLER_OK);
 
228
          }
 
229
        }
 
230
      }
 
231
 
 
232
      PUTBACK;
 
233
    }
 
234
 
 
235
#ifdef DUMPIT
 
236
    fprintf(stderr, "DUMPDUMPDUMPDUMPDUMPDUMP\n");
 
237
    sv_dump(pduinfo);
 
238
    fprintf(stderr, "--------------------\n");
 
239
    sv_dump(varbinds);
 
240
#endif
 
241
    
 
242
    /* svREFCNT_dec((SV *) pduinfo); */
 
243
#ifdef NOT_THIS
 
244
    {
 
245
        SV *vba;
 
246
        while(vba = av_pop(varbinds)) {
 
247
            av_undef((AV *) vba);
 
248
        }
 
249
    }
 
250
    av_undef(varbinds);
 
251
#endif    
 
252
    free(tmparray);
 
253
 
 
254
      if (v2pdu) {
 
255
              snmp_free_pdu(v2pdu);
 
256
      }
 
257
 
 
258
    FREETMPS;
 
259
    LEAVE;
 
260
    return result;
 
261
}
 
262
 
 
263
MODULE = NetSNMP::TrapReceiver          PACKAGE = NetSNMP::TrapReceiver         
 
264
 
 
265
INCLUDE: const-xs.inc
 
266
 
 
267
MODULE = NetSNMP::TrapReceiver PACKAGE = NetSNMP::TrapReceiver PREFIX=trapd_
 
268
int
 
269
trapd_register(regoid, perlcallback)
 
270
        char *regoid;
 
271
        SV   *perlcallback;
 
272
    PREINIT:
 
273
        oid myoid[MAX_OID_LEN];
 
274
        size_t myoid_len = MAX_OID_LEN;
 
275
        trapd_cb_data *cb_data;
 
276
        netsnmp_trapd_handler *handler = NULL;
 
277
    CODE:
 
278
        {
 
279
            if (!regoid || !perlcallback) {
 
280
                RETVAL = 0;
 
281
                return;
 
282
            }
 
283
            if (strcmp(regoid,"all") == 0) {
 
284
                handler = 
 
285
                    netsnmp_add_global_traphandler(NETSNMPTRAPD_POST_HANDLER,
 
286
                                                   perl_trapd_handler);
 
287
            } else if (strcmp(regoid,"default") == 0) {
 
288
                handler = 
 
289
                    netsnmp_add_default_traphandler(perl_trapd_handler);
 
290
            } else if (!snmp_parse_oid(regoid, myoid, &myoid_len)) {
 
291
                snmp_log(LOG_ERR,
 
292
                         "Failed to parse oid for perl registration: %s\n",
 
293
                         regoid);
 
294
                RETVAL = 0;
 
295
                return;
 
296
            } else {
 
297
                handler = 
 
298
                    netsnmp_add_traphandler(perl_trapd_handler,
 
299
                                            myoid, myoid_len);
 
300
            }
 
301
        
 
302
            if (handler) {
 
303
                cb_data = malloc(sizeof(trapd_cb_data));
 
304
                cb_data->perl_cb = newSVsv(perlcallback);
 
305
                handler->handler_data = cb_data;
 
306
                handler->authtypes = (1 << VACM_VIEW_EXECUTE);
 
307
                RETVAL = 1;
 
308
            } else {
 
309
                RETVAL = 0;
 
310
            }
 
311
        }
 
312
    OUTPUT:
 
313
        RETVAL