void main(void)
{
add_lit2uint();
aint0=16;
aint1=0;
add_uint2uint();
aint0 = 0;
aint1 = 32;
aint2 = 0;
add_uint2uint2();
#if SUPPORT_BIT_TYPES
add_bits();
achar0 = 7;
add_bit2uchar();
aint0 = 0;
bit0 = 1;
add_bit2uint();
#endif
aint0 = 0;
addlits();
done();
}
int main(void)
{
add_lit2uchar();
achar0=16;
achar1=0;
add_uchar2uchar();
achar0 = 0;
achar1 = 32;
add_uchar2uchar2();
#ifdef SUPPORT_BIT_TYPES
add_bits();
add_bit2uchar();
add_bit2uint();
#endif
success = failures;
done();
printf("failures: %d\n",failures);
return failures;
}
int main(void)
{
opentest(OUTFILE);
add_lit2uchar();
achar0=16;
achar1=0;
add_uchar2uchar();
achar0 = 0;
achar1 = 32;
add_uchar2uchar2();
#ifdef SUPPORT_BIT_TYPES
add_bits();
add_bit2uchar();
add_bit2uint();
#endif
success = failures;
done();
fprintf(outfile,"failures: %d\n",failures);
closetest(THISFILE);
return (0);
}
/* AU Header dissection */
static offset_struct* dissect_auheader( tvbuff_t *tvb, offset_struct *poffset, packet_info *pinfo, proto_tree *ismacryp_tree, guint set_version )
{
proto_item *ismacryp_item;
proto_tree *ismacryp_header_tree;
proto_tree *ismacryp_header_byte_tree;
guint16 header_len_bytes = 0; /* total length of non-first AU header in bytes (rounded up) */
gint header_len = 0; /* length of AU headers in bits */
gint cts_flag =0;
gint dts_flag =0;
gboolean first_au_flag=FALSE;
gint bit_offset = 0;
/*first determine total AU header length */
/* calculate each AU header length in bits first */
switch (set_version) {
case V11:
if (selective_encryption)
header_len+=8; /* add one byte to header length */
break;
case V20:
if (selective_encryption || slice_indication || padding_indication)
header_len+=8; /* add one byte to header length */
break;
default:
DISSECTOR_ASSERT_NOT_REACHED();
break;
} /* end switch */
header_len+=au_size_length; /* add au size length */
if (poffset->offset_bytes==AU_HEADERS_LENGTH_SIZE){ /*first AU */
header_len+=8*(iv_length); /* add IV length */
header_len+=8*key_indicator_length; /* add key indicator length */
header_len+=au_index_length; /* add AU index length */
first_au_flag = TRUE;
}
else { /* not the first AU */
if (key_indicator_per_au_flag == TRUE)
header_len+=8*key_indicator_length; /* add key indicator length */
header_len+=8*(delta_iv_length); /* add delta IV length */
header_len+=au_index_delta_length; /* add AU delta index length */
}
/* CTS flag is present? */
if (cts_delta_length != 0){ /* need to test whether cts_delta_flag is TRUE or FALSE */
cts_flag=tvb_get_bits8(tvb, AU_HEADERS_LENGTH_SIZE*8+header_len, 1); /*fetch 1 bit CTS flag */
header_len+=1; /* add CTS flag bit */
if (cts_flag==1)
header_len+=cts_delta_length; /* add CTS delta length bits if CTS flag SET */
}
/* DTS flag is present? */
if (dts_delta_length != 0){ /* need to test whether dts_delta_flag is TRUE or FALSE */
dts_flag=tvb_get_bits8(tvb, AU_HEADERS_LENGTH_SIZE*8+header_len, 1); /*fetch 1 bit DTS flag */
header_len+=1; /* add DTS flag bit */
if (dts_flag==1)
header_len+=dts_delta_length; /* add DTS delta length bits if DTS flag SET */
}
/* RAP flag present? */
if (random_access_indication != FALSE)
header_len+=1; /* add 1 bit RAP flag */
/* stream state indication present */
if (stream_state_indication !=0)
header_len+=stream_state_indication; /* add stream state indication bits */
/* convert header_len to bytes (rounded up) */
if (header_len% 8!=0)
{
header_len_bytes=((header_len)/8)+1; /*add 1 */
}
else
header_len_bytes=((header_len)/8);
/* add AU header tree */
ismacryp_item = proto_tree_add_item(ismacryp_tree, hf_ismacryp_header, tvb, poffset->offset_bytes, header_len_bytes, ENC_NA );
proto_item_append_text(ismacryp_item, ": Length=%d bits", header_len); /* add text to Header tree indicating length */
/* sanity check if actual AU header length is zero bits, which indicates an error */
if ( header_len == 0) /* something wrong */
{
proto_item_append_text(ismacryp_item, " Error - zero bit AU header size - check parameters!");
}
ismacryp_header_tree = proto_item_add_subtree(ismacryp_item, ett_ismacryp_header);
/* ismacryp header analysis */
/* we are being asked for details */
/* Extra 1 Byte Header? */
if ((set_version==V20 && (selective_encryption || slice_indication || padding_indication))
|| (set_version==V11 && selective_encryption)){
/* add header byte tree */
ismacryp_item = proto_tree_add_item(ismacryp_header_tree, hf_ismacryp_header_byte,
tvb, poffset->offset_bytes, 1, ENC_NA );
proto_item_append_text(ismacryp_item, ": Length=8 bits"); /* add text to Header byte tree indicating length */
ismacryp_header_byte_tree = proto_item_add_subtree(ismacryp_item, ett_ismacryp_header_byte);
/*ismacryp_header_byte_tree */
/* we are being asked for details */
/* tvb is network order, so get MSB bits first, so shift 8 bits and work "backwards" */
add_bits(poffset,7); /*shift 7 bits to get correct bit */
/* AU_is_encrypted bit */
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
if (selective_encryption){ /* bit used */
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_au_is_encrypted,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /*fetch 1 bit AU_is_encrypted */
}
else { /* bit unused */
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_unused_bits,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /*fetch 1 bit unused */
}
switch (set_version){ /* ISMACryp version? */
case V11:
/* Reserved bits */
add_bits(poffset, -7); /* move back 7 bits for reserved bits */
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_reserved_bits,
tvb, bit_offset, 7, ENC_BIG_ENDIAN); /*fetch 7 bits reserved */
add_bits(poffset,8); /* offset to next byte */
break;
case V20:
/* Slice_start bit */
add_bits(poffset, -1); /* move back 1 bit for slice_start */
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
if (slice_indication){
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_slice_start,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /*fetch 1 bit slice_start */
}
else { /* bit unused */
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_unused_bits,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /*fetch 1 bit unused */
}
add_bits(poffset, -1); /* move back 1 bit for slice_end */
/* Slice_end bit */
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
if (slice_indication){
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_slice_end,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /*fetch 1 bit Slice_end */
}
else { /* bit unused */
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_unused_bits,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /*fetch 1 bit unused */
}
add_bits(poffset, -3); /* move back 3 bits for padding_bitcount */
/* Padding_bitcount bits */
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
if (padding_indication){
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_padding_bitcount,
tvb, bit_offset, 3, ENC_BIG_ENDIAN); /*fetch 3 bits padding_bitcount */
}
else { /* bits unused */
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_unused_bits,
tvb, bit_offset, 3, ENC_BIG_ENDIAN); /*fetch 3 bits unused */
}
add_bits(poffset, -2); /* move back 2 bits for reserved bits */
/* Reserved bits */
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
proto_tree_add_bits_item(ismacryp_header_byte_tree, hf_ismacryp_reserved_bits,
tvb, bit_offset, 2, ENC_BIG_ENDIAN); /*fetch 2 bits reserved */
add_bits(poffset,8); /* offset to next byte */
break;
default:
DISSECTOR_ASSERT_NOT_REACHED();
break;
} /* end switch set_version */
} /* end selective encryption */
/* IV */
if (first_au_flag == TRUE && iv_length != 0)
{
ismacryp_item = proto_tree_add_item(ismacryp_header_tree, hf_ismacryp_iv, tvb, poffset->offset_bytes, iv_length, ENC_NA);
proto_item_append_text(ismacryp_item, ": Length=%d bytes",iv_length); /* add IV info */
col_append_fstr( pinfo->cinfo, COL_INFO,
", IV=0x%s", tvb_bytes_to_str_punct(tvb, poffset->offset_bytes, iv_length,' '));
poffset->offset_bytes+=iv_length; /* add IV length to offset_bytes */
}
/*Delta IV */
if (first_au_flag == FALSE && delta_iv_length != 0)
{
ismacryp_item = proto_tree_add_item(ismacryp_header_tree, hf_ismacryp_delta_iv,
tvb, poffset->offset_bytes, delta_iv_length, ENC_NA);
proto_item_append_text(ismacryp_item, ": Length=%d bytes",delta_iv_length); /* add delta IV info */
col_append_fstr( pinfo->cinfo, COL_INFO,
", Delta IV=0x%s", tvb_bytes_to_str_punct(tvb, poffset->offset_bytes, delta_iv_length,' '));
poffset->offset_bytes+=iv_length; /* add IV length to offset_bytes */
}
/* Key Indicator */
if ( key_indicator_length != 0 && ( first_au_flag == TRUE || key_indicator_per_au_flag == TRUE) )
{
/* (first AU or KI for each AU) and non-zero KeyIndicator size */
ismacryp_item = proto_tree_add_item(ismacryp_header_tree, hf_ismacryp_key_indicator,
tvb, poffset->offset_bytes, key_indicator_length, ENC_NA);
proto_item_append_text(ismacryp_item,": Length=%d bytes",key_indicator_length); /* add KI info */
col_append_fstr( pinfo->cinfo, COL_INFO,
", KI=0x%s", tvb_bytes_to_str_punct(tvb, poffset->offset_bytes, key_indicator_length,' '));
poffset->offset_bytes+=key_indicator_length; /* add KI length to offset_bytes */
}
/* AU size */
if (au_size_length != 0) /* in bits */
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
ismacryp_item = proto_tree_add_bits_item(ismacryp_header_tree,hf_ismacryp_au_size,
tvb, bit_offset, au_size_length, ENC_BIG_ENDIAN);
proto_item_append_text(ismacryp_item, " bytes: Length=%d bits",au_size_length); /* add AU size info */
/*bit_offset+=au_size_length;*/
add_bits(poffset, au_size_length);
}
/* AU Index */
if (first_au_flag == TRUE && au_index_length != 0) /* first AU and non-zero AU size */
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
ismacryp_item = proto_tree_add_bits_item(ismacryp_header_tree,hf_ismacryp_au_index,
tvb, bit_offset, au_index_length, ENC_BIG_ENDIAN);
proto_item_append_text(ismacryp_item, " bits: Length=%d bits",au_index_length); /* add AU index info */
/*bit_offset+=au_index_length;*/
add_bits(poffset, au_index_length);
}
/* AU index delta */
if (first_au_flag == FALSE && au_index_delta_length != 0) /* not first AU and non-zero AU delta size */
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
ismacryp_item = proto_tree_add_bits_item(ismacryp_header_tree,hf_ismacryp_au_index_delta,
tvb, bit_offset, au_index_delta_length, ENC_BIG_ENDIAN);
proto_item_append_text(ismacryp_item, ": Length=%d bits", au_index_delta_length); /* add AU index info */
/*bit_offset+=au_index_delta_length;*/
add_bits(poffset, au_index_delta_length);
}
/* CTS delta value */
if (cts_delta_length != 0)
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
proto_tree_add_bits_item(ismacryp_header_tree, hf_ismacryp_cts_flag,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /* read CTS flag */
add_bits(poffset, 1);
if (cts_flag==1)
{
/* now fetch CTS delta value (remember offset 1 bit due to CTS flag) */
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
ismacryp_item = proto_tree_add_bits_item(ismacryp_header_tree, hf_ismacryp_cts_delta,
tvb, bit_offset, cts_delta_length, ENC_BIG_ENDIAN); /* read CTS delta value */
proto_item_append_text(ismacryp_item, ": Length=%d bits",cts_delta_length); /* add CTS delta info */
add_bits(poffset, cts_delta_length);
}
}
/* DTS delta value */
if (dts_delta_length != 0)
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
proto_tree_add_bits_item(ismacryp_header_tree, hf_ismacryp_dts_flag,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /* read DTS flag */
add_bits(poffset, 1);
/* now fetch DTS delta value (remember offset x bits due to DTS flag) */
if (dts_flag ==1)
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
ismacryp_item = proto_tree_add_bits_item(ismacryp_header_tree, hf_ismacryp_dts_delta,
tvb, bit_offset, dts_delta_length, ENC_BIG_ENDIAN); /* read DTS delta value */
proto_item_append_text(ismacryp_item, ": Length=%d bits",dts_delta_length); /* add DTS delta info */
add_bits(poffset, dts_delta_length);
}
}
/* RAP */
if (random_access_indication != FALSE)
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
proto_tree_add_bits_item(ismacryp_header_tree, hf_ismacryp_rap_flag,
tvb, bit_offset, 1, ENC_BIG_ENDIAN); /* read RAP flag */
add_bits(poffset, 1);
}
/*STREAM STATE */
if (stream_state_indication != 0)
{
bit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
proto_tree_add_bits_item(ismacryp_header_tree, hf_ismacryp_stream_state,
tvb, bit_offset, stream_state_indication, ENC_BIG_ENDIAN); /* read stream state */
add_bits(poffset, stream_state_indication);
}
/* end header details */
return poffset;
}
static void dissect_ismacryp_common(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, guint ismacryp_version)
{
guint set_version; /* ISMACryp version used during dissection */
proto_item *ismacryp_item;
proto_tree *ismacryp_tree;
proto_tree *ismacryp_message_tree;
/* select and display ISMACryp version */
if ((ismacryp_version!=version_type) && override_flag){
/* override -> use manual preference setting */
col_append_str(pinfo->cinfo, COL_INFO, " Manual version");
set_version = version_type; /* set to preference value */
}
else {
set_version = ismacryp_version;
}
if (set_version == V11){
col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_ISMACRYP_11);
/* display mode */
if (pref_user_mode == FALSE){
col_append_fstr(pinfo->cinfo, COL_INFO, ", %s",val_to_str_const(mode, modetypenames, "user mode"));
} else {
col_append_str(pinfo->cinfo, COL_INFO, ", user mode");
}
user_mode = pref_user_mode;
}
if (set_version == V20){
col_set_str(pinfo->cinfo, COL_PROTOCOL, PROTO_TAG_ISMACRYP_20);
user_mode = TRUE;
/* display mode */
col_append_str(pinfo->cinfo, COL_INFO, ", user mode");
}
/* select correct AU values depending on version & selected mode in preferences menu if not in user_mode */
if (user_mode == TRUE){ /* use values set in preference menu */
au_size_length = pref_au_size_length;
au_index_length = pref_au_index_length;
au_index_delta_length = pref_au_index_delta_length;
cts_delta_length = pref_cts_delta_length;
dts_delta_length = pref_dts_delta_length;
random_access_indication = pref_random_access_indication;
stream_state_indication = pref_stream_state_indication;
} /* end if user_mode == TRUE */
if (user_mode == FALSE){
switch (mode){
case AAC_HBR_MODE:
au_size_length = 13;
au_index_length = 3;
au_index_delta_length = 3;
cts_delta_length = 0;
dts_delta_length = 0;
random_access_indication = FALSE;
stream_state_indication = 0;
break;
case MPEG4_VIDEO_MODE:
au_size_length = 0;
au_index_length = 0;
au_index_delta_length = 0;
cts_delta_length = 0;
dts_delta_length = 22;
random_access_indication = TRUE;
stream_state_indication = 0;
break;
case AVC_VIDEO_MODE:
au_size_length = 0;
au_index_length = 0;
au_index_delta_length = 0;
cts_delta_length = 0;
dts_delta_length = 22;
random_access_indication = TRUE;
stream_state_indication = 0;
break;
default:
DISSECTOR_ASSERT_NOT_REACHED();
break;
} /* end switch */
} /* end if user_mode == FALSE */
/* navigate through buffer */
if (tree)
{
/* we are being asked for details */
guint16 au_headers_length = 0; /* total length of AU headers */
guint16 totalbits =0; /* keeps track of total number of AU header bits treated (used to determine end of AU headers) */
int deltabits = -1; /* keeps track of extra bits per AU header treated (used to determine end of AU heafers ) */
guint16 totalbit_offset = 0; /* total offset in bits*/
int nbpadding_bits = 0; /* number of padding bits*/
offset_struct s_offset;
offset_struct* poffset;
guint16 nbmessage_bytes = 0; /*nb of message data bytes */
s_offset.offset_bytes = 0; /* initialise byte offset */
s_offset.offset_bits = 0; /* initialise bit offset */
poffset = &s_offset;
ismacryp_item = proto_tree_add_item(tree, proto_ismacryp, tvb, 0, -1, ENC_NA);
ismacryp_tree = proto_item_add_subtree(ismacryp_item, ett_ismacryp);
proto_item_append_text(tree, ", %s", "ismacryp packet"); /* add text to tree */
/* ismacryp_tree analysis */
/* we are being asked for details */
/* get total length of AU headers (first 2 bytes) */
ismacryp_item = proto_tree_add_item(ismacryp_tree, hf_ismacryp_au_headers_length,
tvb, poffset->offset_bytes, AU_HEADERS_LENGTH_SIZE, ENC_BIG_ENDIAN );
proto_item_append_text(ismacryp_item, " (bits)"); /* add text to AU Header tree indicating length */
au_headers_length=tvb_get_ntohs(tvb,poffset->offset_bytes); /* 2 byte au headers length */
poffset->offset_bytes+=AU_HEADERS_LENGTH_SIZE;
/* ADD HEADER(S) BRANCH */
/* AU Header loop */
totalbits=(poffset->offset_bytes*8)+poffset->offset_bits;
while( ((totalbits-8*AU_HEADERS_LENGTH_SIZE)<au_headers_length) && deltabits!=0 ) /* subtract AU headers length bits*/
{
poffset=dissect_auheader( tvb, poffset, pinfo, ismacryp_tree, set_version);
deltabits=(poffset->offset_bytes*8)+poffset->offset_bits - totalbits; /* if zero this means no actual AU header so exit while loop */
totalbits+=deltabits;
}
/* reached end of AU Header(s) */
/* sanity check if actual total AU headers length in bits i.e. totalbits is */
/* the same as expected AU headers length from 2 bytes at start of buffer */
if ( (totalbits-8*AU_HEADERS_LENGTH_SIZE) != au_headers_length) /* something wrong */
{
proto_item_append_text(ismacryp_item,
" Error - expected total AU headers size (%d bits) "
"does not match calculated size (%d bits) - check parameters!",
au_headers_length,(totalbits-8*AU_HEADERS_LENGTH_SIZE));
}
/* add padding if need to byte align */
if (poffset->offset_bits!=0)
{
totalbit_offset = (poffset->offset_bytes)*8+poffset->offset_bits; /* offset in bits */
nbpadding_bits = (8-poffset->offset_bits); /* number of padding bits for byte alignment */
ismacryp_item = proto_tree_add_bits_item(ismacryp_tree, hf_ismacryp_padding,
tvb, totalbit_offset, nbpadding_bits , ENC_BIG_ENDIAN); /* padding bits */
proto_item_append_text(ismacryp_item, ": Length=%d bits",nbpadding_bits); /* add padding info */
add_bits(poffset, nbpadding_bits);
}
/* ADD MESSAGE BRANCH */
ismacryp_item = proto_tree_add_item( ismacryp_tree, hf_ismacryp_message,
tvb, poffset->offset_bytes, -1, ENC_NA );
ismacryp_message_tree = proto_item_add_subtree(ismacryp_item, ett_ismacryp_message);
proto_item_append_text(ismacryp_item, ", %s", "Encrypted data"); /* add text to Message tree */
nbmessage_bytes = tvb_reported_length_remaining(tvb, poffset->offset_bytes);
proto_item_append_text(ismacryp_item, ", Length= %d bytes", nbmessage_bytes ); /* add length of message */
/* ismacryp message tree analysis (encrypted AUs) */
if (ismacryp_message_tree)
{ /* we are being asked for details */
poffset->offset_bytes+= nbmessage_bytes; /* */
} /* end message details */
/* end ismacryp tree details */
} /* end if tree */
}
