2007-05-04 08:24:06 +00:00
|
|
|
/* asn1.c
|
|
|
|
* Common routines for ASN.1
|
|
|
|
* 2007 Anders Broman
|
|
|
|
*
|
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
2018-02-08 16:59:17 +00:00
|
|
|
* SPDX-License-Identifier: GPL-2.0-or-later
|
2007-05-04 08:24:06 +00:00
|
|
|
*/
|
|
|
|
|
2012-09-20 01:48:30 +00:00
|
|
|
#include "config.h"
|
2007-05-04 08:24:06 +00:00
|
|
|
|
2007-05-17 14:36:32 +00:00
|
|
|
#include <glib.h>
|
|
|
|
|
|
|
|
#include <string.h>
|
2007-05-14 13:39:31 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <math.h>
|
2015-10-09 13:45:41 +00:00
|
|
|
#ifdef DEBUG
|
|
|
|
#include <stdio.h>
|
2016-07-24 12:53:39 +00:00
|
|
|
#include <wsutil/ws_printf.h> /* ws_debug_printf */
|
2015-10-09 13:45:41 +00:00
|
|
|
#endif
|
2007-05-14 13:39:31 +00:00
|
|
|
|
2007-05-04 08:24:06 +00:00
|
|
|
#include <epan/packet.h>
|
|
|
|
|
|
|
|
#include "asn1.h"
|
|
|
|
|
|
|
|
void asn1_ctx_init(asn1_ctx_t *actx, asn1_enc_e encoding, gboolean aligned, packet_info *pinfo) {
|
2007-05-14 13:39:31 +00:00
|
|
|
memset(actx, '\0', sizeof(*actx));
|
|
|
|
actx->signature = ASN1_CTX_SIGNATURE;
|
2007-05-04 08:24:06 +00:00
|
|
|
actx->encoding = encoding;
|
|
|
|
actx->aligned = aligned;
|
|
|
|
actx->pinfo = pinfo;
|
2007-05-14 13:39:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
gboolean asn1_ctx_check_signature(asn1_ctx_t *actx) {
|
2007-07-18 13:15:36 +00:00
|
|
|
return actx && (actx->signature == ASN1_CTX_SIGNATURE);
|
2007-05-04 08:24:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void asn1_ctx_clean_external(asn1_ctx_t *actx) {
|
|
|
|
memset(&actx->external, '\0', sizeof(actx->external));
|
|
|
|
actx->external.hf_index = -1;
|
2007-07-18 13:15:36 +00:00
|
|
|
actx->external.encoding = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
void asn1_ctx_clean_epdv(asn1_ctx_t *actx) {
|
|
|
|
memset(&actx->embedded_pdv, '\0', sizeof(actx->embedded_pdv));
|
|
|
|
actx->embedded_pdv.hf_index = -1;
|
|
|
|
actx->embedded_pdv.identification = -1;
|
|
|
|
}
|
|
|
|
|
2007-08-29 11:44:49 +00:00
|
|
|
|
|
|
|
/*--- stack/parameters ---*/
|
|
|
|
|
|
|
|
void asn1_stack_frame_push(asn1_ctx_t *actx, const gchar *name) {
|
|
|
|
asn1_stack_frame_t *frame;
|
|
|
|
|
2015-01-11 00:04:06 +00:00
|
|
|
frame = wmem_new0(wmem_packet_scope(), asn1_stack_frame_t);
|
2007-08-29 11:44:49 +00:00
|
|
|
frame->name = name;
|
|
|
|
frame->next = actx->stack;
|
|
|
|
actx->stack = frame;
|
|
|
|
}
|
|
|
|
|
|
|
|
void asn1_stack_frame_pop(asn1_ctx_t *actx, const gchar *name) {
|
|
|
|
DISSECTOR_ASSERT(actx->stack);
|
|
|
|
DISSECTOR_ASSERT(!strcmp(actx->stack->name, name));
|
|
|
|
actx->stack = actx->stack->next;
|
|
|
|
}
|
|
|
|
|
|
|
|
void asn1_stack_frame_check(asn1_ctx_t *actx, const gchar *name, const asn1_par_def_t *par_def) {
|
|
|
|
const asn1_par_def_t *pd = par_def;
|
|
|
|
asn1_par_t *par;
|
|
|
|
|
|
|
|
DISSECTOR_ASSERT(actx->stack);
|
|
|
|
DISSECTOR_ASSERT(!strcmp(actx->stack->name, name));
|
|
|
|
|
|
|
|
par = actx->stack->par;
|
|
|
|
while (pd->name) {
|
|
|
|
DISSECTOR_ASSERT(par);
|
|
|
|
DISSECTOR_ASSERT((pd->ptype == ASN1_PAR_IRR) || (par->ptype == pd->ptype));
|
|
|
|
par->name = pd->name;
|
|
|
|
pd++;
|
|
|
|
par = par->next;
|
|
|
|
}
|
|
|
|
DISSECTOR_ASSERT(!par);
|
|
|
|
}
|
|
|
|
|
|
|
|
static asn1_par_t *get_par_by_name(asn1_ctx_t *actx, const gchar *name) {
|
|
|
|
asn1_par_t *par = NULL;
|
|
|
|
|
|
|
|
DISSECTOR_ASSERT(actx->stack);
|
|
|
|
par = actx->stack->par;
|
|
|
|
while (par) {
|
|
|
|
if (!strcmp(par->name, name))
|
|
|
|
return par;
|
|
|
|
par = par->next;
|
|
|
|
}
|
|
|
|
return par;
|
|
|
|
}
|
|
|
|
|
|
|
|
static asn1_par_t *push_new_par(asn1_ctx_t *actx) {
|
|
|
|
asn1_par_t *par, **pp;
|
|
|
|
|
|
|
|
DISSECTOR_ASSERT(actx->stack);
|
|
|
|
|
2015-01-11 00:04:06 +00:00
|
|
|
par = wmem_new0(wmem_packet_scope(), asn1_par_t);
|
2007-08-29 11:44:49 +00:00
|
|
|
|
|
|
|
pp = &(actx->stack->par);
|
|
|
|
while (*pp)
|
|
|
|
pp = &((*pp)->next);
|
|
|
|
*pp = par;
|
|
|
|
|
|
|
|
return par;
|
|
|
|
}
|
|
|
|
|
2007-12-28 10:42:44 +00:00
|
|
|
void asn1_param_push_boolean(asn1_ctx_t *actx, gboolean value) {
|
|
|
|
asn1_par_t *par;
|
|
|
|
|
|
|
|
par = push_new_par(actx);
|
|
|
|
par->ptype = ASN1_PAR_BOOLEAN;
|
|
|
|
par->value.v_boolean = value;
|
|
|
|
}
|
|
|
|
|
2007-08-29 11:44:49 +00:00
|
|
|
void asn1_param_push_integer(asn1_ctx_t *actx, gint32 value) {
|
|
|
|
asn1_par_t *par;
|
|
|
|
|
|
|
|
par = push_new_par(actx);
|
|
|
|
par->ptype = ASN1_PAR_INTEGER;
|
|
|
|
par->value.v_integer = value;
|
|
|
|
}
|
|
|
|
|
2007-12-28 10:42:44 +00:00
|
|
|
gboolean asn1_param_get_boolean(asn1_ctx_t *actx, const gchar *name) {
|
|
|
|
asn1_par_t *par = NULL;
|
|
|
|
|
|
|
|
par = get_par_by_name(actx, name);
|
|
|
|
DISSECTOR_ASSERT(par);
|
|
|
|
return par->value.v_boolean;
|
|
|
|
}
|
|
|
|
|
2007-08-29 11:44:49 +00:00
|
|
|
gint32 asn1_param_get_integer(asn1_ctx_t *actx, const gchar *name) {
|
|
|
|
asn1_par_t *par = NULL;
|
|
|
|
|
|
|
|
par = get_par_by_name(actx, name);
|
|
|
|
DISSECTOR_ASSERT(par);
|
|
|
|
return par->value.v_integer;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*--- ROSE ---*/
|
|
|
|
|
2007-07-18 13:15:36 +00:00
|
|
|
void rose_ctx_init(rose_ctx_t *rctx) {
|
|
|
|
memset(rctx, '\0', sizeof(*rctx));
|
|
|
|
rctx->signature = ROSE_CTX_SIGNATURE;
|
|
|
|
}
|
|
|
|
|
|
|
|
gboolean rose_ctx_check_signature(rose_ctx_t *rctx) {
|
|
|
|
return rctx && (rctx->signature == ROSE_CTX_SIGNATURE);
|
|
|
|
}
|
|
|
|
|
|
|
|
void rose_ctx_clean_data(rose_ctx_t *rctx) {
|
|
|
|
memset(&rctx->d, '\0', sizeof(rctx->d));
|
|
|
|
rctx->d.code = -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
asn1_ctx_t *get_asn1_ctx(void *ptr) {
|
|
|
|
asn1_ctx_t *actx = (asn1_ctx_t*)ptr;
|
|
|
|
|
2014-02-25 20:42:35 +00:00
|
|
|
if (!asn1_ctx_check_signature(actx))
|
2007-07-18 13:15:36 +00:00
|
|
|
actx = NULL;
|
|
|
|
|
|
|
|
return actx;
|
|
|
|
}
|
|
|
|
|
|
|
|
rose_ctx_t *get_rose_ctx(void *ptr) {
|
|
|
|
rose_ctx_t *rctx = (rose_ctx_t*)ptr;
|
|
|
|
asn1_ctx_t *actx = (asn1_ctx_t*)ptr;
|
|
|
|
|
2014-02-25 20:42:35 +00:00
|
|
|
if (!asn1_ctx_check_signature(actx))
|
2007-07-18 13:15:36 +00:00
|
|
|
actx = NULL;
|
|
|
|
|
|
|
|
if (actx)
|
|
|
|
rctx = actx->rose_ctx;
|
|
|
|
|
2014-02-25 20:42:35 +00:00
|
|
|
if (!rose_ctx_check_signature(rctx))
|
2007-07-18 13:15:36 +00:00
|
|
|
rctx = NULL;
|
|
|
|
|
|
|
|
return rctx;
|
2007-05-04 08:24:06 +00:00
|
|
|
}
|
2007-05-14 13:39:31 +00:00
|
|
|
|
2014-11-28 15:53:04 +00:00
|
|
|
/** Only tested for BER */
|
|
|
|
double asn1_get_real(const guint8 *real_ptr, gint len) {
|
2007-05-14 13:39:31 +00:00
|
|
|
guint8 octet;
|
|
|
|
const guint8 *p;
|
|
|
|
guint8 *buf;
|
|
|
|
double val = 0;
|
|
|
|
|
2014-11-28 15:53:04 +00:00
|
|
|
/* 8.5.2 If the real value is the value zero,
|
|
|
|
* there shall be no contents octets in the encoding.
|
|
|
|
*/
|
|
|
|
if (len < 1) return val;
|
|
|
|
|
2007-05-14 13:39:31 +00:00
|
|
|
octet = real_ptr[0];
|
|
|
|
p = real_ptr + 1;
|
2014-11-28 15:53:04 +00:00
|
|
|
len -= 1;
|
2007-05-14 13:39:31 +00:00
|
|
|
if (octet & 0x80) { /* binary encoding */
|
2014-11-28 15:53:04 +00:00
|
|
|
int i;
|
|
|
|
gboolean Eneg;
|
|
|
|
gint8 S; /* Sign */
|
|
|
|
guint8 B; /* Base */
|
|
|
|
guint8 F; /* scaling Factor */
|
|
|
|
gint32 E = 0; /* Exponent (supported max 3 octets/24 bit) */
|
|
|
|
guint64 N = 0; /* N (supported max 8 octets/64 bit) */
|
|
|
|
|
|
|
|
guint8 lenE, lenN;
|
|
|
|
|
|
|
|
if(octet & 0x40) S = -1; else S = 1;
|
|
|
|
switch(octet & 0x30) {
|
|
|
|
case 0x00: B = 2; break;
|
|
|
|
case 0x10: B = 8; break;
|
|
|
|
case 0x20: B = 16; break;
|
|
|
|
case 0x30: /* Reserved */
|
|
|
|
default:
|
|
|
|
/* TODO Add some warning in tree about reserved value for Base */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
F = (octet & 0x0c) >> 2;
|
|
|
|
|
|
|
|
/* 8.5.6.4 Exponent length */
|
|
|
|
lenE = (octet & 0x3) + 1;
|
|
|
|
if(lenE == 4)
|
|
|
|
{
|
|
|
|
/* we can't handle exponents > 24 bits */
|
|
|
|
/* TODO Next octet(s) define length of exponent */
|
|
|
|
DISSECTOR_ASSERT_NOT_REACHED();
|
|
|
|
}
|
|
|
|
|
|
|
|
Eneg = (*p) & 0x80 ? TRUE : FALSE;
|
|
|
|
for (i = 0; i < lenE; i++) {
|
|
|
|
if(Eneg) {
|
|
|
|
/* 2's complement: inverse bits */
|
|
|
|
E = (E<<8) | ((guint8) ~(*p));
|
|
|
|
} else {
|
|
|
|
E = (E<<8) | *p;
|
|
|
|
}
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
if(Eneg) {
|
|
|
|
/* 2's complement: ... and add 1 (and make negative of course) */
|
|
|
|
E = -(E + 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
lenN = len - lenE;
|
|
|
|
if(lenN > 8)
|
|
|
|
{
|
|
|
|
/* we can't handle integers > 64 bits */
|
|
|
|
DISSECTOR_ASSERT_NOT_REACHED();
|
|
|
|
}
|
|
|
|
for (i=0; i<lenN; i++) {
|
|
|
|
N = (N<<8) | *p;
|
|
|
|
p++;
|
|
|
|
}
|
|
|
|
val = (double) S * N * pow(2, F) * pow(B, E);
|
|
|
|
#ifdef DEBUG
|
2016-07-24 12:53:39 +00:00
|
|
|
ws_debug_printf("S = %d, N = %lu, F = %u, B = %u, E = %d -> %f\n", S, N, F, B, E, val);
|
2014-11-28 15:53:04 +00:00
|
|
|
#endif
|
2007-05-14 13:39:31 +00:00
|
|
|
} else if (octet & 0x40) { /* SpecialRealValue */
|
|
|
|
switch (octet & 0x3F) {
|
|
|
|
case 0x00: val = HUGE_VAL; break;
|
|
|
|
case 0x01: val = -HUGE_VAL; break;
|
|
|
|
}
|
|
|
|
} else { /* decimal encoding */
|
2015-01-11 00:04:06 +00:00
|
|
|
buf = g_strndup(p, len);
|
2015-06-25 00:05:30 +00:00
|
|
|
val = g_ascii_strtod(buf, NULL);
|
2015-01-11 00:04:06 +00:00
|
|
|
g_free(buf);
|
2007-05-14 13:39:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return val;
|
|
|
|
}
|
2014-10-10 14:41:10 +00:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Editor modelines - http://www.wireshark.org/tools/modelines.html
|
|
|
|
*
|
|
|
|
* Local Variables:
|
|
|
|
* c-basic-offset: 2
|
|
|
|
* tab-width: 8
|
|
|
|
* indent-tabs-mode: nil
|
|
|
|
* End:
|
|
|
|
*
|
|
|
|
* ex: set shiftwidth=2 tabstop=8 expandtab:
|
|
|
|
* :indentSize=2:tabSize=8:noTabs=true:
|
|
|
|
*/
|