// Copyright 2015 Brian Smith.

//

// Permission to use, copy, modify, and/or distribute this software for any

// purpose with or without fee is hereby granted, provided that the above

// copyright notice and this permission notice appear in all copies.

//

// THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES

// WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

// MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

// ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

// WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

// ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

// OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

use crate::{calendar, time, Error};

pub(crate) use ring::io::der::{CONSTRUCTED, CONTEXT_SPECIFIC};

// Copied (and extended) from ring's src/der.rs

#[allow(clippy::upper_case_acronyms)]

#[derive(Clone, Copy, Eq, PartialEq)]

#[repr(u8)]

pub(crate) enum Tag {

    Boolean = 0x01,

    Integer = 0x02,

    BitString = 0x03,

    OctetString = 0x04,

    OID = 0x06,

    Enum = 0x0A,

    Sequence = CONSTRUCTED | 0x10, // 0x30

    UTCTime = 0x17,

    GeneralizedTime = 0x18,

    #[allow(clippy::identity_op)]

    ContextSpecificConstructed0 = CONTEXT_SPECIFIC | CONSTRUCTED | 0,

    ContextSpecificConstructed1 = CONTEXT_SPECIFIC | CONSTRUCTED | 1,

    ContextSpecificConstructed3 = CONTEXT_SPECIFIC | CONSTRUCTED | 3,

}

impl From<Tag> for usize {

    #[allow(clippy::as_conversions)]

}

impl From<Tag> for u8 {

    #[allow(clippy::as_conversions)]

}

#[inline(always)]

#[inline(always)]

// TODO: investigate taking decoder as a reference to reduce generated code

// size.

pub(crate) struct Value<'a> {

    value: untrusted::Input<'a>,

}

impl<'a> Value<'a> {

}

#[inline(always)]

#[inline(always)]

    // If the high order bit of the first byte is set to zero then the length

    // is encoded in the seven remaining bits of that byte. Otherwise, those

    // seven bits represent the number of bytes used to encode the length.

        LONG_FORM_LEN_ONE_BYTE => {

        }

        LONG_FORM_LEN_TWO_BYTES => {

        }

        LONG_FORM_LEN_THREE_BYTES => {

        }

        LONG_FORM_LEN_FOUR_BYTES => {

        }

        _ => {

        }

    };

// Long-form DER encoded lengths of two bytes can express lengths up to the following limit.

//

// The upstream ring::io::der::read_tag_and_get_value() function limits itself to up to two byte

// long-form DER lengths, and so this limit represents the maximum length that was possible to

// read before the introduction of the read_tag_and_get_value_limited function.

pub(crate) const TWO_BYTE_DER_SIZE: usize = LONG_FORM_LEN_TWO_BYTES_MAX;

// The maximum size of a DER value that Webpki can support reading.

//

// Webpki limits itself to four byte long-form DER lengths, and so this limit represents

// the maximum size tagged DER value that can be read for any purpose.

pub(crate) const MAX_DER_SIZE: usize = LONG_FORM_LEN_FOUR_BYTES_MAX;

// DER Tag identifiers have two forms:

// * Low tag number form (for tags values in the range [0..30]

// * High tag number form (for tag values in the range [31..]

// We only support low tag number form.

const HIGH_TAG_RANGE_START: u8 = 31;

// DER length octets have two forms:

// * Short form: 1 octet supporting lengths between 0 and 127.

// * Long definite form: 2 to 127 octets, number of octets encoded into first octet.

const SHORT_FORM_LEN_MAX: u8 = 128;

// Leading octet for long definite form DER length expressed in second byte.

const LONG_FORM_LEN_ONE_BYTE: u8 = 0x81;

// Maximum size that can be expressed in a one byte long form len.

const LONG_FORM_LEN_ONE_BYTE_MAX: usize = 0xff;

// Leading octet for long definite form DER length expressed in subsequent two bytes.

const LONG_FORM_LEN_TWO_BYTES: u8 = 0x82;

// Maximum size that can be expressed in a two byte long form len.

const LONG_FORM_LEN_TWO_BYTES_MAX: usize = 0xff_ff;

// Leading octet for long definite form DER length expressed in subsequent three bytes.

const LONG_FORM_LEN_THREE_BYTES: u8 = 0x83;

// Maximum size that can be expressed in a three byte long form len.

const LONG_FORM_LEN_THREE_BYTES_MAX: usize = 0xff_ff_ff;

// Leading octet for long definite form DER length expressed in subsequent four bytes.

const LONG_FORM_LEN_FOUR_BYTES: u8 = 0x84;

// Maximum size that can be expressed in a four byte long form der len.

const LONG_FORM_LEN_FOUR_BYTES_MAX: usize = 0xff_ff_ff_ff;

// TODO: investigate taking decoder as a reference to reduce generated code

// size.

        loop {

        }

pub(crate) struct BitStringFlags<'a> {

    raw_bits: &'a [u8],

}

impl<'a> BitStringFlags<'a> {

        } else {

        }

}

// ASN.1 BIT STRING fields for sets of flags are encoded in DER with some peculiar details related

// to padding. Notably this means we expect a Tag::BitString, a length, an indicator of the number

// of bits of padding, and then the actual bit values. See this Stack Overflow discussion[0], and

// ITU X690-0207[1] Section 8.6 and Section 11.2 for more information.

//

// [0]: https://security.stackexchange.com/a/10396

// [1]: https://www.itu.int/ITU-T/studygroups/com17/languages/X.690-0207.pdf

        // ITU X690-0207 11.2:

        //   "The initial octet shall encode, as an unsigned binary integer with bit 1 as the least

        //   significant bit, the number of unused bits in the final subsequent octet.

        //   The number shall be in the range zero to seven"

        }

// Like mozilla::pkix, we accept the nonconformant explicit encoding of

// the default value (false) for compatibility with real-world certificates.

        }

    } else {

    };

        const DIGIT: core::ops::RangeInclusive<u8> = b'0'..=b'9';

        } else {

        };

macro_rules! oid {

    ( $first:expr, $second:expr, $( $tail:expr ),* ) =>

    (

        [(40 * $first) + $second, $( $tail ),*]

    )

}

#[cfg(test)]

mod tests {

    #[test]

    fn test_optional_boolean() {

        use super::{optional_boolean, Error};

        // Empty input results in false

        assert!(!optional_boolean(&mut bytes_reader(&[])).unwrap());

        // Optional, so another data type results in false

        assert!(!optional_boolean(&mut bytes_reader(&[0x05, 0x00])).unwrap());

        // Only 0x00 and 0xff are accepted values

        assert_eq!(

            optional_boolean(&mut bytes_reader(&[0x01, 0x01, 0x42])).unwrap_err(),

            Error::BadDer,

        );

        // True

        assert!(optional_boolean(&mut bytes_reader(&[0x01, 0x01, 0xff])).unwrap());

        // False

        assert!(!optional_boolean(&mut bytes_reader(&[0x01, 0x01, 0x00])).unwrap());

    }

    #[test]

    fn test_bit_string_with_no_unused_bits() {

        use super::{bit_string_with_no_unused_bits, Error};

        // Unexpected type

        assert_eq!(

            bit_string_with_no_unused_bits(&mut bytes_reader(&[0x01, 0x01, 0xff])).unwrap_err(),

            Error::BadDer,

        );

        // Unexpected nonexistent type

        assert_eq!(

            bit_string_with_no_unused_bits(&mut bytes_reader(&[0x42, 0xff, 0xff])).unwrap_err(),

            Error::BadDer,

        );

        // Unexpected empty input

        assert_eq!(

            bit_string_with_no_unused_bits(&mut bytes_reader(&[])).unwrap_err(),

            Error::BadDer,

        );

        // Valid input with non-zero unused bits

        assert_eq!(

            bit_string_with_no_unused_bits(&mut bytes_reader(&[0x03, 0x03, 0x04, 0x12, 0x34]))

                .unwrap_err(),

            Error::BadDer,

        );

        // Valid input

        assert_eq!(

            bit_string_with_no_unused_bits(&mut bytes_reader(&[0x03, 0x03, 0x00, 0x12, 0x34]))

                .unwrap()

                .as_slice_less_safe(),

            &[0x12, 0x34],

        );

    }

    fn bytes_reader(bytes: &[u8]) -> untrusted::Reader {

        return untrusted::Reader::new(untrusted::Input::from(bytes));

    }

    #[test]

    fn read_tag_and_get_value_default_limit() {

        use super::{read_tag_and_get_value, Error};

        let inputs = &[

            // DER with short-form length encoded as three bytes.

            &[EXAMPLE_TAG, 0x83, 0xFF, 0xFF, 0xFF].as_slice(),

            // DER with short-form length encoded as four bytes.

            &[EXAMPLE_TAG, 0x84, 0xFF, 0xFF, 0xFF, 0xFF].as_slice(),

        ];

        for input in inputs {

            let mut bytes = untrusted::Reader::new(untrusted::Input::from(input));

            // read_tag_and_get_value should reject DER with encoded lengths larger than two

            // bytes as BadDer.

            assert!(matches!(

                read_tag_and_get_value(&mut bytes),

                Err(Error::BadDer)

            ));

        }

    }

    #[test]

    fn read_tag_and_get_value_limited_high_form() {

        use super::{read_tag_and_get_value_limited, Error, LONG_FORM_LEN_TWO_BYTES_MAX};

        let mut bytes = untrusted::Reader::new(untrusted::Input::from(&[0xFF]));

        // read_tag_and_get_value_limited_high_form should reject DER with "high tag number form" tags.

        assert!(matches!(

            read_tag_and_get_value_limited(&mut bytes, LONG_FORM_LEN_TWO_BYTES_MAX),

            Err(Error::BadDer)

        ));

    }

    #[test]

    fn read_tag_and_get_value_limited_non_canonical() {

        use super::{read_tag_and_get_value_limited, Error, LONG_FORM_LEN_TWO_BYTES_MAX};

        let inputs = &[

            // Two byte length, with expressed length < 128.

            &[EXAMPLE_TAG, 0x81, 0x01].as_slice(),

            // Three byte length, with expressed length < 256.

            &[EXAMPLE_TAG, 0x82, 0x00, 0x01].as_slice(),

            // Four byte length, with expressed length, < 65536.

            &[EXAMPLE_TAG, 0x83, 0x00, 0x00, 0x01].as_slice(),

            // Five byte length, with expressed length < 16777216.

            &[EXAMPLE_TAG, 0x84, 0x00, 0x00, 0x00, 0x01].as_slice(),

        ];

        for input in inputs {

            let mut bytes = untrusted::Reader::new(untrusted::Input::from(input));

            // read_tag_and_get_value_limited should reject DER with non-canonical lengths.

            assert!(matches!(

                read_tag_and_get_value_limited(&mut bytes, LONG_FORM_LEN_TWO_BYTES_MAX),

                Err(Error::BadDer)

            ));

        }

    }

    #[test]

    #[cfg(feature = "alloc")]

    fn read_tag_and_get_value_limited_limits() {

        use super::{read_tag_and_get_value_limited, Error};

        let short_input = &[0xFF];

        let short_input_encoded = &[

            &[EXAMPLE_TAG],

            der_encode_length(short_input.len()).as_slice(),

            short_input,

        ]

        .concat();

        let long_input = &[1_u8; 65537];

        let long_input_encoded = &[

            &[EXAMPLE_TAG],

            der_encode_length(long_input.len()).as_slice(),

            long_input,

        ]

        .concat();

        struct Testcase<'a> {

            input: &'a [u8],

            limit: usize,

            err: Option<Error>,

        }

        let testcases = &[

            Testcase {

                input: short_input_encoded,

                limit: 1,

                err: Some(Error::BadDer),

            },

            Testcase {

                input: short_input_encoded,

                limit: short_input_encoded.len() + 1,

                err: None,

            },

            Testcase {

                input: long_input_encoded,

                limit: long_input.len(),

                err: Some(Error::BadDer),

            },

            Testcase {

                input: long_input_encoded,

                limit: long_input.len() + 1,

                err: None,

            },

        ];

        for tc in testcases {

            let mut bytes = untrusted::Reader::new(untrusted::Input::from(tc.input));

            let res = read_tag_and_get_value_limited(&mut bytes, tc.limit);

            match tc.err {

                None => assert!(res.is_ok()),

                Some(e) => {

                    let actual = res.unwrap_err();

                    assert_eq!(actual, e)

                }

            }

        }

    }

    #[allow(clippy::as_conversions)] // infallible.

    const EXAMPLE_TAG: u8 = super::Tag::Sequence as u8;

    #[cfg(feature = "alloc")]

    #[allow(clippy::as_conversions)] // test code.

    fn der_encode_length(length: usize) -> Vec<u8> {

        if length < 128 {

            vec![length as u8]

        } else {

            let mut encoded: Vec<u8> = Vec::new();

            let mut remaining_length = length;

            while remaining_length > 0 {

                let byte = (remaining_length & 0xFF) as u8;

                encoded.insert(0, byte);

                remaining_length >>= 8;

            }

            let length_octet = encoded.len() as u8 | 0x80;

            encoded.insert(0, length_octet);

            encoded

        }

    }

    #[allow(clippy::as_conversions)] // infallible.

    const BITSTRING_TAG: u8 = super::Tag::BitString as u8;

    #[test]

    fn misencoded_bit_string_flags() {

        use super::{bit_string_flags, Error};

        let mut bad_padding_example = untrusted::Reader::new(untrusted::Input::from(&[

            BITSTRING_TAG, // BitString

            0x2,           // 2 bytes of content.

            0x08,          // 8 bit of padding (illegal!).

            0x06,          // 1 byte of bit flags asserting bits 5 and 6.

        ]));

        assert!(matches!(

            bit_string_flags(&mut bad_padding_example),

            Err(Error::BadDer)

        ));

        let mut bad_padding_example = untrusted::Reader::new(untrusted::Input::from(&[

            BITSTRING_TAG, // BitString

            0x2,           // 2 bytes of content.

            0x01,          // 1 bit of padding.

                           // No flags value (illegal with padding!).

        ]));

        assert!(matches!(

            bit_string_flags(&mut bad_padding_example),

            Err(Error::BadDer)

        ));

        let mut trailing_zeroes = untrusted::Reader::new(untrusted::Input::from(&[

            BITSTRING_TAG, // BitString

            0x2,           // 2 bytes of content.

            0x01,          // 1 bit of padding.

            0xFF,          // Flag data with

            0x00,          // trailing zeros.

        ]));

        assert!(matches!(

            bit_string_flags(&mut trailing_zeroes),

            Err(Error::BadDer)

        ))

    }

    #[test]

    fn valid_bit_string_flags() {

        use super::bit_string_flags;

        let mut example_key_usage = untrusted::Reader::new(untrusted::Input::from(&[

            BITSTRING_TAG, // BitString

            0x2,           // 2 bytes of content.

            0x01,          // 1 bit of padding.

            0x06,          // 1 byte of bit flags asserting bits 5 and 6.

        ]));

        let res = bit_string_flags(&mut example_key_usage).unwrap();

        assert!(!res.bit_set(0));

        assert!(!res.bit_set(1));

        assert!(!res.bit_set(2));

        assert!(!res.bit_set(3));

        assert!(!res.bit_set(4));

        // NB: Bits 5 and 6 should be set.

        assert!(res.bit_set(5));

        assert!(res.bit_set(6));

        assert!(!res.bit_set(7));

        assert!(!res.bit_set(8));

        // Bits outside the range of values shouldn't be considered set.

        assert!(!res.bit_set(256));

    }

}