handle context-specific tag incorrect about der-parser HOT 9 CLOSED

fn der_read_element_content_recursive<'a>(
    i: &'a [u8],
    hdr: DerObjectHeader<'a>,
    max_depth: usize,
) -> DerResult<'a> {
    match hdr.class {
        DerClass::Universal | DerClass::Private => (),
        _ => {
            let (i, content) = ber_get_object_content(i, &hdr, max_depth)?;
            let content = DerObjectContent::Unknown(hdr.tag, content);
            let obj = DerObject::from_header_and_content(hdr, content);
            return Ok((i, obj));
        }
    }
    match der_read_element_content_as(i, hdr.tag, hdr.len, hdr.is_constructed(), max_depth) {
        Ok((rem, content)) => Ok((rem, DerObject::from_header_and_content(hdr, content))),
        Err(Err::Error(BerError::UnknownTag)) => {
            let (rem, content) = ber_get_object_content(i, &hdr, max_depth)?;
            let content = DerObjectContent::Unknown(hdr.tag, content);
            let obj = DerObject::from_header_and_content(hdr, content);
            Ok((rem, obj))
        }
        Err(e) => Err(e),
    }
}

fn reparse_unknown_o<'a>(o: BerObject<'a>) -> BerResult<'a> {
    // Workaround for https://github.com/rusticata/der-parser/issues/38.

    let new_o = match o.content {
        BerObjectContent::Sequence(v) => {
            let (_, new_v) = reparse_unknown_v(v)?;
            BerObject::from_header_and_content(o.header, BerObjectContent::Sequence(new_v))
        }

        BerObjectContent::Set(v) => {
            let (_, new_v) = reparse_unknown_v(v)?;
            BerObject::from_header_and_content(o.header, BerObjectContent::Set(new_v))
        }

        BerObjectContent::Optional(Some(boxed_obj)) => {
            let (_, new_o) = reparse_unknown_o(*boxed_obj)?;
            BerObject::from_header_and_content(
                o.header,
                BerObjectContent::Optional(Some(Box::new(new_o))),
            )
        }

        BerObjectContent::Tagged(class, tag, boxed_obj) => {
            let (_, new_o) = reparse_unknown_o(*boxed_obj)?;
            BerObject::from_header_and_content(
                o.header,
                BerObjectContent::Tagged(class, tag, Box::new(new_o)),
            )
        }

        BerObjectContent::Unknown(_tag, data) => {
            if o.header.class == BerClass::ContextSpecific && o.header.structured == 1 {
                // Tagged entries may contain multiple objects. The BerObjectContent enum
                // doesn't have a way to represent this directly, so we wrap this in an
                // implicit sequence.

                let mut objs: Vec<BerObject<'a>> = Vec::new();
                let mut i = data;
                while !i.is_empty() {
                    let (i2, obj) = parse_der(i)?;
                    let (_, obj) = reparse_unknown_o(obj)?;
                    objs.push(obj);
                    i = i2;
                }

                BerObject::from_header_and_content(o.header, BerObjectContent::Sequence(objs))
            } else {
                o
            }
        }

        _ => o,
    };

    Ok((&[], new_o))
}

fn reparse_unknown_v<'a>(v: Vec<BerObject<'a>>) -> BerResult<Vec<BerObject<'a>>> {
    let new_v: Result<Vec<BerObject<'a>>, nom::Err<BerError>> = v
        .into_iter()
        .map(|o| match reparse_unknown_o(o) {
            Ok((_i, new_o)) => Ok(new_o),
            Err(e) => Err(e),
        })
        .collect();

    match new_v {
        Ok(v) => Ok((&[], v)),
        Err(e) => Err(e),
    }
}