// Copyright (c) 2020 Intel Corporation

//

// SPDX-License-Identifier: Apache-2.0 or MIT

use fuzzlib::{

    spdmlib::common::session::{SpdmSession, SpdmSessionState},

    spdmlib::common::SpdmConnectionState,

    spdmlib::protocol::{SpdmBaseHashAlgo, SpdmVersion},

    *,

};

use spdmlib::protocol::*;

use spin::Mutex;

extern crate alloc;

use alloc::sync::Arc;

async fn fuzz_handle_spdm_certificate(data: Arc<Vec<u8>>) {

    spdmlib::secret::asym_sign::register(SECRET_ASYM_IMPL_INSTANCE.clone());

    spdmlib::secret::pqc_asym_sign::register(SECRET_PQC_ASYM_IMPL_INSTANCE.clone());

    // TCD:

    // - id: 0

    // - title: 'Fuzz SPDM handle certificate request'

    // - description: '<p>Responder send certificate response to requester.</p>'

    // -

    {

        let (config_info, provision_info) = rsp_create_info();

        let pcidoe_transport_encap = Arc::new(Mutex::new(PciDoeTransportEncap {}));

        let shared_buffer = SharedBuffer::new();

        let socket_io_transport = Arc::new(Mutex::new(FakeSpdmDeviceIoReceve::new(Arc::new(

            shared_buffer,

        ))));

        let mut context = responder::ResponderContext::new(

            socket_io_transport,

            pcidoe_transport_encap,

            config_info,

            provision_info,

        );

        context.common.negotiate_info.spdm_version_sel = SpdmVersion::SpdmVersion12;

        context.common.negotiate_info.base_hash_sel = SpdmBaseHashAlgo::TPM_ALG_SHA_384;

        context.common.provision_info.my_cert_chain = [

            Some(get_rsp_cert_chain_buff()),

            None,

            None,

            None,

            None,

            None,

            None,

            None,

        ];

        context

            .common

            .runtime_info

            .set_connection_state(SpdmConnectionState::SpdmConnectionNegotiated);

        let mut response_buffer = [0u8; spdmlib::config::MAX_SPDM_MSG_SIZE];

        let mut writer = codec::Writer::init(&mut response_buffer);

        let _ = context.handle_spdm_certificate(&data, None, &mut writer);

    }

    // TCD:

    // - id: 0

    // - title: 'Fuzz SPDM handle certificate request'

    // - description: '<p>Responder send certificate response to requester in session.</p>'

    // -

    {

        let (config_info, provision_info) = rsp_create_info();

        let pcidoe_transport_encap = Arc::new(Mutex::new(PciDoeTransportEncap {}));

        let shared_buffer = SharedBuffer::new();

        let socket_io_transport = Arc::new(Mutex::new(FakeSpdmDeviceIoReceve::new(Arc::new(

            shared_buffer,

        ))));

        let mut context = responder::ResponderContext::new(

            socket_io_transport,

            pcidoe_transport_encap,

            config_info,

            provision_info,

        );

        context.common.negotiate_info.spdm_version_sel = SpdmVersion::SpdmVersion12;

        context.common.negotiate_info.base_hash_sel = SpdmBaseHashAlgo::TPM_ALG_SHA_384;

        context.common.provision_info.my_cert_chain = [

            Some(get_rsp_cert_chain_buff()),

            None,

            None,

            None,

            None,

            None,

            None,

            None,

        ];

        context.common.session[0] = SpdmSession::new();

        context.common.session[0].setup(4294836221).unwrap();

        context.common.session[0].set_session_state(SpdmSessionState::SpdmSessionEstablished);

        context.common.session[0].set_crypto_param(

            SpdmBaseHashAlgo::TPM_ALG_SHA_384,

            SpdmDheAlgo::SECP_384_R1,

            SpdmKemAlgo::empty(),

            SpdmAeadAlgo::AES_256_GCM,

            SpdmKeyScheduleAlgo::SPDM_KEY_SCHEDULE,

        );

        context

            .common

            .runtime_info

            .set_connection_state(SpdmConnectionState::SpdmConnectionNegotiated);

        let mut response_buffer = [0u8; spdmlib::config::MAX_SPDM_MSG_SIZE];

        let mut writer = codec::Writer::init(&mut response_buffer);

        let _ = context.handle_spdm_certificate(&data, Some(4294836221), &mut writer);

    }

}

#[cfg(not(feature = "use_libfuzzer"))]

fn main() {

    #[cfg(all(feature = "fuzzlogfile", feature = "fuzz"))]

    flexi_logger::Logger::try_with_str("info")

        .unwrap()

        .log_to_file(

            FileSpec::default()

                .directory("traces")

                .basename("foo")

                .discriminant("Sample4711A")

                .suffix("trc"),

        )

        .print_message()

        .create_symlink("current_run")

        .start()

        .unwrap();

    #[cfg(not(feature = "fuzz"))]

    {

        let args: Vec<String> = std::env::args().collect();

        if args.len() < 2 {

            // Here you can replace the single-step debugging value in the fuzzdata array.

            let fuzzdata = vec![

                17, 227, 4, 0, 48, 0, 1, 0, 128, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

                0, 0, 0, 0, 0, 0, 2, 32, 16, 0, 3, 32, 2, 0, 4, 32, 2, 0, 5, 32, 1, 0,

            ];

            executor::block_on(fuzz_handle_spdm_certificate(Arc::new(fuzzdata)));

        } else {

            let path = &args[1];

            let data = std::fs::read(path).expect("read crash file fail");

            executor::block_on(fuzz_handle_spdm_certificate(Arc::new(data)));

        }

    }

    #[cfg(feature = "fuzz")]

    afl::fuzz!(|data: &[u8]| {

        executor::block_on(fuzz_handle_spdm_certificate(Arc::new(data.to_vec())));

    });

}