#![deny(missing_docs)]
#![warn(clippy::all, clippy::pedantic)]
#![allow(clippy::missing_errors_doc, clippy::must_use_candidate)]

//! `rsa_export` allows you to export your RSA key, generated via the [rsa crate](https://crates.io/crates/rsa), with PKCS#1 or PKCS#8 encoding  
//!
//! **Note**: Multi-prime keys are not supported
//!
//! The keys can also be exported into the PEM format by enabling the feature `pem`
//!
//! Example:  
//!
//! ```rust
//! use rsa::RSAPrivateKey;
//! use rand::rngs::OsRng;
//!
//! let mut rng = OsRng;
//! let key = RSAPrivateKey::new(&mut rng, 2048).unwrap();
//! let private_key = rsa_export::RsaKey::new(key);
//! let public_key = private_key.public_key();
//!
//! let pkcs1_encoded_private = private_key.as_pkcs1().unwrap();
//! let pkcs1_encoded_public = public_key.as_pkcs1().unwrap();
//!
//! let pkcs8_encoded_private = private_key.as_pkcs8().unwrap();
//! let pkcs8_encoded_public = public_key.as_pkcs8().unwrap();
//! ```
//!
//! Encode PKCS#1 or PKCS#8 encoded keys into the PEM format
//!
//! ```rust
//! use rsa::RSAPrivateKey;
//! use rand::rngs::OsRng;
//!
//! let mut rng = OsRng;
//! let key = RSAPrivateKey::new(&mut rng, 2048).unwrap();
//! let private_key = rsa_export::RsaKey::new(key);
//! let public_key = private_key.public_key();
//!
//! let pkcs1_encoded_private_pem = private_key.as_pkcs1_pem().unwrap();
//! let pkcs1_encoded_public_pem = public_key.as_pkcs1_pem().unwrap();
//!
//! let pkcs8_encoded_private_pem = private_key.as_pkcs8_pem().unwrap();
//! let pkcs8_encoded_public_pem = public_key.as_pkcs8_pem().unwrap();
//! ```
//!
//! Encode PKCS#1 or PKCS#8 encoded keys into the PEM format with a custom line ending
//!
//! ```rust
//! use rsa::RSAPrivateKey;
//! use rsa_export::LineEnding;
//! use rand::rngs::OsRng;
//!
//! let mut rng = OsRng;
//! let key = RSAPrivateKey::new(&mut rng, 2048).unwrap();
//! let mut private_key = rsa_export::RsaKey::new(key);
//!
//! private_key.set_line_ending(LineEnding::CRLF);
//!
//! let public_key = private_key.public_key();
//!
//! let pkcs1_encoded_private_pem = private_key.as_pkcs1_pem().unwrap();
//! let pkcs1_encoded_public_pem = public_key.as_pkcs1_pem().unwrap();
//!
//! let pkcs8_encoded_private_pem = private_key.as_pkcs8_pem().unwrap();
//! let pkcs8_encoded_public_pem = public_key.as_pkcs8_pem().unwrap();
//! ```
//!

#[cfg(feature = "pem")]
extern crate pem as pem_crate;

use {
    crate::error::Error,
    num_bigint_dig::ToBigInt,
    rsa::{RSAPrivateKey, RSAPublicKey},
};

fn rsa_oid() -> simple_asn1::OID {
    use simple_asn1::{BigUint, OID};

    simple_asn1::oid!(1, 2, 840, 113_549, 1, 1, 1)
}

fn to_bigint(biguint: &rsa::BigUint) -> simple_asn1::BigInt {
    simple_asn1::BigInt::from_signed_bytes_le(
        biguint.to_bigint().unwrap().to_signed_bytes_le().as_slice(),
    )
}

/// Wrapper struct for the RSA key
pub struct RsaKey<T: Encode> {
    key: T,

    #[cfg(feature = "pem")]
    line_ending: LineEnding,
}

impl<T: Encode> RsaKey<T> {
    /// Create a new wrapper, wrapping around the given key
    pub fn new(key: T) -> Self {
        Self {
            key,

            #[cfg(feature = "pem")]
            line_ending: LineEnding::LF,
        }
    }

    /// Get the key which the wrapper is wrapping around
    pub fn into_inner(self) -> T {
        self.key
    }

    /// Encode the key in the PKCS#1 format
    pub fn as_pkcs1(&self) -> Result<Vec<u8>, Error> {
        self.key.encode_pkcs1()
    }

    /// Encode the key in the PKCS#8 format
    pub fn as_pkcs8(&self) -> Result<Vec<u8>, Error> {
        self.key.encode_pkcs8()
    }
}

#[cfg(feature = "pem")]
impl<T: Encode> RsaKey<T> {
    /// Set the line ending for the PEM keys (default: unix-style)
    pub fn set_line_ending(&mut self, line_ending: LineEnding) {
        self.line_ending = line_ending;
    }

    /// Encode the key in the PKCS#1 format inside a PEM block (unix-style line ending)
    pub fn as_pkcs1_pem(&self) -> Result<String, Error> {
        let pkcs1_key = self.as_pkcs1()?;

        Ok(pem::encode(
            pem::EncodingScheme::PKCS1,
            self.key.key_type(),
            self.line_ending,
            pkcs1_key,
        ))
    }

    /// Encode the key in the PKCS#8 format inside a PEM block (unix-style line ending)
    pub fn as_pkcs8_pem(&self) -> Result<String, Error> {
        let pkcs8_key = self.as_pkcs8()?;

        Ok(pem::encode(
            pem::EncodingScheme::PKCS8,
            self.key.key_type(),
            self.line_ending,
            pkcs8_key,
        ))
    }
}

impl RsaKey<RSAPrivateKey> {
    /// Convenience function to create the public key version
    pub fn public_key(&self) -> RsaKey<RSAPublicKey> {
        RsaKey {
            key: self.key.to_public_key(),

            #[cfg(feature = "pem")]
            line_ending: self.line_ending,
        }
    }
}

/// Trait to reduce copy-pasted code for the PKCS#1 and PKCS#8 encoding  
pub trait Encode: sealed::Sealed {
    #[cfg(feature = "pem")]
    /// Get the key type
    fn key_type(&self) -> pem::KeyType;

    /// Encode in the PKCS#1 format
    fn encode_pkcs1(&self) -> Result<Vec<u8>, Error>;
    /// Encode in the PKCS#8 format
    fn encode_pkcs8(&self) -> Result<Vec<u8>, Error>;
}

impl Encode for RSAPrivateKey {
    #[cfg(feature = "pem")]
    fn key_type(&self) -> pem::KeyType {
        pem::KeyType::Private
    }

    fn encode_pkcs1(&self) -> Result<Vec<u8>, Error> {
        pkcs1::private_key(self)
    }

    fn encode_pkcs8(&self) -> Result<Vec<u8>, Error> {
        pkcs8::private_key(self)
    }
}

impl Encode for RSAPublicKey {
    #[cfg(feature = "pem")]
    fn key_type(&self) -> pem::KeyType {
        pem::KeyType::Public
    }

    fn encode_pkcs1(&self) -> Result<Vec<u8>, Error> {
        pkcs1::public_key(self)
    }

    fn encode_pkcs8(&self) -> Result<Vec<u8>, Error> {
        pkcs8::public_key(self)
    }
}

#[cfg(feature = "pem")]
pub use pem_crate::LineEnding;

mod sealed {
    pub trait Sealed {}

    impl Sealed for rsa::RSAPrivateKey {}
    impl Sealed for rsa::RSAPublicKey {}
}

/// Error type
pub mod error;

/// Encode a public/private key with PKCS#1
mod pkcs1;
/// Encode a public/private key with PKCS#8
mod pkcs8;

#[cfg(feature = "pem")]
/// Encode a public/private key encoded with PKCS#1 or PKCS#8 into the PEM format
mod pem;

#[cfg(test)]
mod test;