epan/asn1.c

   1 /* asn1.c
   2  * Common routines for ASN.1
   3  * 2007  Anders Broman
   4  *
   5  * Wireshark - Network traffic analyzer
   6  * By Gerald Combs <gerald@wireshark.org>
   7  * Copyright 1998 Gerald Combs
   8  *
   9  * SPDX-License-Identifier: GPL-2.0-or-later
  10  */
  11
  12 #include "config.h"
  13
  14 #include <glib.h>
  15
  16 #include <string.h>
  17 #include <stdlib.h>
  18 #include <math.h>
  19
  20 #include <epan/packet.h>
  21
  22 #include "asn1.h"
  23
  24 void asn1_ctx_init(asn1_ctx_t *actx, asn1_enc_e encoding, bool aligned, packet_info *pinfo) {
  25   memset(actx, '\0', sizeof(*actx));
  26   actx->signature = ASN1_CTX_SIGNATURE;
  27   actx->encoding = encoding;
  28   actx->aligned = aligned;
  29   actx->pinfo = pinfo;
  30 }
  31
  32 bool asn1_ctx_check_signature(asn1_ctx_t *actx) {
  33   return actx && (actx->signature == ASN1_CTX_SIGNATURE);
  34 }
  35
  36 void asn1_ctx_clean_external(asn1_ctx_t *actx) {
  37   memset(&actx->external, '\0', sizeof(actx->external));
  38   actx->external.hf_index = -1;
  39   actx->external.encoding = -1;
  40 }
  41
  42 void asn1_ctx_clean_epdv(asn1_ctx_t *actx) {
  43   memset(&actx->embedded_pdv, '\0', sizeof(actx->embedded_pdv));
  44   actx->embedded_pdv.hf_index = -1;
  45   actx->embedded_pdv.identification = -1;
  46 }
  47
  48
  49 /*--- stack/parameters ---*/
  50
  51 void asn1_stack_frame_push(asn1_ctx_t *actx, const char *name) {
  52   asn1_stack_frame_t *frame;
  53
  54   frame = wmem_new0(actx->pinfo->pool, asn1_stack_frame_t);
  55   frame->name = name;
  56   frame->next = actx->stack;
  57   actx->stack = frame;
  58 }
  59
  60 void asn1_stack_frame_pop(asn1_ctx_t *actx, const char *name) {
  61   DISSECTOR_ASSERT(actx->stack);
  62   DISSECTOR_ASSERT(!strcmp(actx->stack->name, name));
  63   actx->stack = actx->stack->next;
  64 }
  65
  66 void asn1_stack_frame_check(asn1_ctx_t *actx, const char *name, const asn1_par_def_t *par_def) {
  67   const asn1_par_def_t *pd = par_def;
  68   asn1_par_t *par;
  69
  70   DISSECTOR_ASSERT(actx->stack);
  71   DISSECTOR_ASSERT(!strcmp(actx->stack->name, name));
  72
  73   par = actx->stack->par;
  74   while (pd->name) {
  75     DISSECTOR_ASSERT(par);
  76     DISSECTOR_ASSERT((pd->ptype == ASN1_PAR_IRR) || (par->ptype == pd->ptype));
  77     par->name = pd->name;
  78     pd++;
  79     par = par->next;
  80   }
  81   DISSECTOR_ASSERT(!par);
  82 }
  83
  84 static asn1_par_t *get_par_by_name(asn1_ctx_t *actx, const char *name) {
  85   asn1_par_t *par = NULL;
  86
  87   DISSECTOR_ASSERT(actx->stack);
  88   par = actx->stack->par;
  89   while (par) {
  90     if (!strcmp(par->name, name))
  91       return par;
  92     par = par->next;
  93   }
  94   return par;
  95 }
  96
  97 static asn1_par_t *push_new_par(asn1_ctx_t *actx) {
  98   asn1_par_t *par, **pp;
  99
 100   DISSECTOR_ASSERT(actx->stack);
 101
 102   par = wmem_new0(actx->pinfo->pool, asn1_par_t);
 103
 104   pp = &(actx->stack->par);
 105   while (*pp)
 106     pp = &((*pp)->next);
 107   *pp = par;
 108
 109   return par;
 110 }
 111
 112 void asn1_param_push_boolean(asn1_ctx_t *actx, bool value) {
 113   asn1_par_t *par;
 114
 115   par = push_new_par(actx);
 116   par->ptype = ASN1_PAR_BOOLEAN;
 117   par->value.v_boolean = value;
 118 }
 119
 120 void asn1_param_push_integer(asn1_ctx_t *actx, int32_t value) {
 121   asn1_par_t *par;
 122
 123   par = push_new_par(actx);
 124   par->ptype = ASN1_PAR_INTEGER;
 125   par->value.v_integer = value;
 126 }
 127
 128 bool asn1_param_get_boolean(asn1_ctx_t *actx, const char *name) {
 129   asn1_par_t *par = NULL;
 130
 131   par = get_par_by_name(actx, name);
 132   DISSECTOR_ASSERT(par);
 133   return par->value.v_boolean;
 134 }
 135
 136 int32_t asn1_param_get_integer(asn1_ctx_t *actx, const char *name) {
 137   asn1_par_t *par = NULL;
 138
 139   par = get_par_by_name(actx, name);
 140   DISSECTOR_ASSERT(par);
 141   return par->value.v_integer;
 142 }
 143
 144
 145 /*--- ROSE ---*/
 146
 147 void rose_ctx_init(rose_ctx_t *rctx) {
 148   memset(rctx, '\0', sizeof(*rctx));
 149   rctx->signature = ROSE_CTX_SIGNATURE;
 150 }
 151
 152 bool rose_ctx_check_signature(rose_ctx_t *rctx) {
 153   return rctx && (rctx->signature == ROSE_CTX_SIGNATURE);
 154 }
 155
 156 void rose_ctx_clean_data(rose_ctx_t *rctx) {
 157   memset(&rctx->d, '\0', sizeof(rctx->d));
 158   rctx->d.code = -1;
 159 }
 160
 161 asn1_ctx_t *get_asn1_ctx(void *ptr) {
 162   asn1_ctx_t *actx = (asn1_ctx_t*)ptr;
 163
 164   if (!asn1_ctx_check_signature(actx))
 165     actx = NULL;
 166
 167   return actx;
 168 }
 169
 170 rose_ctx_t *get_rose_ctx(void *ptr) {
 171   rose_ctx_t *rctx = (rose_ctx_t*)ptr;
 172   asn1_ctx_t *actx = (asn1_ctx_t*)ptr;
 173
 174   if (!asn1_ctx_check_signature(actx))
 175     actx = NULL;
 176
 177   if (actx)
 178     rctx = actx->rose_ctx;
 179
 180   if (!rose_ctx_check_signature(rctx))
 181     rctx = NULL;
 182
 183   return rctx;
 184 }
 185
 186 /** Only tested for BER */
 187 double asn1_get_real(const uint8_t *real_ptr, int len) {
 188   uint8_t octet;
 189   const uint8_t *p;
 190   uint8_t *buf;
 191   double val = 0;
 192
 193   /* 8.5.2    If the real value is the value zero,
 194    *          there shall be no contents octets in the encoding.
 195    */
 196   if (len < 1) return val;
 197
 198   octet = real_ptr[0];
 199   p = real_ptr + 1;
 200   len -= 1;
 201   if (octet & 0x80) {  /* binary encoding */
 202     int i;
 203     bool Eneg;
 204     int8_t S; /* Sign */
 205     uint8_t B; /* Base */
 206     uint8_t F; /* scaling Factor */
 207     int32_t E = 0; /* Exponent (supported max 3 octets/24 bit) */
 208     uint64_t N = 0; /* N (supported max 8 octets/64 bit) */
 209
 210     uint8_t lenE, lenN;
 211
 212     if(octet & 0x40) S = -1; else S = 1;
 213     switch(octet & 0x30) {
 214       case 0x00: B = 2; break;
 215       case 0x10: B = 8; break;
 216       case 0x20: B = 16; break;
 217       case 0x30: /* Reserved */
 218       default:
 219         /* TODO Add some warning in tree about reserved value for Base */
 220         return 0;
 221     }
 222     F = (octet & 0x0c) >> 2;
 223
 224     /* 8.5.6.4 Exponent length */
 225     lenE = (octet & 0x3) + 1;
 226
 227     /* we can't handle exponents > 24 bits */
 228     /* TODO Next octet(s) define length of exponent */
 229     DISSECTOR_ASSERT(lenE != 4);
 230
 231     /* Ensure the buffer len and its content are coherent */
 232     DISSECTOR_ASSERT(lenE < len);
 233
 234     Eneg = ((*p) & 0x80) ? true : false;
 235     for (i = 0; i < lenE; i++) {
 236       if(Eneg) {
 237         /* 2's complement: inverse bits */
 238         E = (E<<8) | ((uint8_t) ~(*p));
 239       } else {
 240         E = (E<<8) | *p;
 241       }
 242       p++;
 243     }
 244     if(Eneg) {
 245       /* 2's complement: ... and add 1 (and make negative of course) */
 246       E = -(E + 1);
 247     }
 248
 249     lenN = len - lenE;
 250
 251     /* we can't handle integers > 64 bits */
 252     DISSECTOR_ASSERT(lenN <= 8);
 253
 254     for (i=0; i<lenN; i++) {
 255       N = (N<<8) | *p;
 256       p++;
 257     }
 258     val = (double) S * N * pow(2, F) * pow(B, E);
 259   } else if (octet & 0x40) {  /* SpecialRealValue */
 260     switch (octet & 0x3F) {
 261       case 0x00: val = HUGE_VAL; break;
 262       case 0x01: val = -HUGE_VAL; break;
 263       case 0x02: val = NAN; break;
 264     }
 265   } else {  /* decimal encoding */
 266     buf = g_strndup(p, len);
 267     val = g_ascii_strtod(buf, NULL);
 268     g_free(buf);
 269   }
 270
 271   return val;
 272 }
 273
 274 /*
 275  * Editor modelines  -  https://www.wireshark.org/tools/modelines.html
 276  *
 277  * Local Variables:
 278  * c-basic-offset: 2
 279  * tab-width: 8
 280  * indent-tabs-mode: nil
 281  * End:
 282  *
 283  * ex: set shiftwidth=2 tabstop=8 expandtab:
 284  * :indentSize=2:tabSize=8:noTabs=true:
 285  */