Struct apple_codesign::app_store_connect::UnifiedApiKey

pub struct UnifiedApiKey { /* private fields */ }

Represents all metadata for an App Store Connect API Key.

This is a convenience type to aid in the generic representation of all the components of an App Store Connect API Key. The type supports serialization so we save as a single file or payload to enhance usability (so people don’t need to provide all 3 pieces of the API Key for all operations).

Implementations

impl UnifiedApiKey

pub fn from_ecdsa_pem_path(
    issuer_id: impl ToString,
    key_id: impl ToString,
    path: impl AsRef<Path>
) -> Result<Self, AppleCodesignError>

Construct an instance from constitute parts and a PEM encoded ECDSA private key.

This is what you want to use if importing a private key from the file downloaded from the App Store Connect web interface.

Examples found in repository

src/cli.rs (line 1112)

fn command_encode_app_store_connect_api_key(args: &ArgMatches) -> Result<(), AppleCodesignError> {
    let issuer_id = args
        .get_one::<String>("issuer_id")
        .expect("arg should have been required");
    let key_id = args
        .get_one::<String>("key_id")
        .expect("arg should have been required");
    let private_key_path = args
        .get_one::<PathBuf>("private_key_path")
        .expect("arg should have been required");

    let unified = UnifiedApiKey::from_ecdsa_pem_path(issuer_id, key_id, private_key_path)?;

    if let Some(output_path) = args.get_one::<PathBuf>("output_path") {
        eprintln!("writing unified key JSON to {}", output_path.display());
        unified.write_json_file(output_path)?;
        eprintln!(
            "consider auditing the file's access permissions to ensure its content remains secure"
        );
    } else {
        println!("{}", unified.to_json_string()?);
    }

    Ok(())
}

pub fn from_json(data: impl AsRef<[u8]>) -> Result<Self, AppleCodesignError>

Construct an instance from serialized JSON.

Examples found in repository

src/app_store_connect/mod.rs (line 91)

    pub fn from_json_path(path: impl AsRef<Path>) -> Result<Self, AppleCodesignError> {
        let data = std::fs::read(path.as_ref())?;

        Self::from_json(data)
    }

pub fn from_json_path(
    path: impl AsRef<Path>
) -> Result<Self, AppleCodesignError>

Construct an instance from a JSON file.

Examples found in repository

src/cli.rs (line 1911)

fn notarizer_from_args(
    args: &ArgMatches,
) -> Result<crate::notarization::Notarizer, AppleCodesignError> {
    let api_key_path = args.get_one::<PathBuf>("api_key_path");
    let api_issuer = args.get_one::<String>("api_issuer");
    let api_key = args.get_one::<String>("api_key");

    let mut notarizer = crate::notarization::Notarizer::new()?;

    if let Some(api_key_path) = api_key_path {
        let unified = UnifiedApiKey::from_json_path(api_key_path)?;
        notarizer.set_token_encoder(unified.try_into()?);
    } else if let (Some(issuer), Some(key)) = (api_issuer, api_key) {
        notarizer.set_api_key(issuer, key)?;
    }

    Ok(notarizer)
}

pub fn to_json_string(&self) -> Result<String, AppleCodesignError>

Serialize this instance to a JSON object.

Examples found in repository

src/app_store_connect/mod.rs (line 114)

    pub fn write_json_file(&self, path: impl AsRef<Path>) -> Result<(), AppleCodesignError> {
        let path = path.as_ref();

        if let Some(parent) = path.parent() {
            std::fs::create_dir_all(parent)?;
        }

        let data = self.to_json_string()?;

        let mut fh = std::fs::File::create(path)?;
        let mut permissions = fh.metadata()?.permissions();
        set_permissions_private(&mut permissions);
        fh.set_permissions(permissions)?;
        fh.write_all(data.as_bytes())?;

        Ok(())
    }

src/cli.rs (line 1121)

fn command_encode_app_store_connect_api_key(args: &ArgMatches) -> Result<(), AppleCodesignError> {
    let issuer_id = args
        .get_one::<String>("issuer_id")
        .expect("arg should have been required");
    let key_id = args
        .get_one::<String>("key_id")
        .expect("arg should have been required");
    let private_key_path = args
        .get_one::<PathBuf>("private_key_path")
        .expect("arg should have been required");

    let unified = UnifiedApiKey::from_ecdsa_pem_path(issuer_id, key_id, private_key_path)?;

    if let Some(output_path) = args.get_one::<PathBuf>("output_path") {
        eprintln!("writing unified key JSON to {}", output_path.display());
        unified.write_json_file(output_path)?;
        eprintln!(
            "consider auditing the file's access permissions to ensure its content remains secure"
        );
    } else {
        println!("{}", unified.to_json_string()?);
    }

    Ok(())
}

pub fn write_json_file(
    &self,
    path: impl AsRef<Path>
) -> Result<(), AppleCodesignError>

Write this instance to a JSON file.

Since the file contains sensitive data, it will have limited read permissions on platforms where this is implemented. Parent directories will be created if missing using default permissions for created directories.

Permissions on the resulting file may not be as restrictive as desired. It is up to callers to additionally harden as desired.

Examples found in repository

src/cli.rs (line 1116)

fn command_encode_app_store_connect_api_key(args: &ArgMatches) -> Result<(), AppleCodesignError> {
    let issuer_id = args
        .get_one::<String>("issuer_id")
        .expect("arg should have been required");
    let key_id = args
        .get_one::<String>("key_id")
        .expect("arg should have been required");
    let private_key_path = args
        .get_one::<PathBuf>("private_key_path")
        .expect("arg should have been required");

    let unified = UnifiedApiKey::from_ecdsa_pem_path(issuer_id, key_id, private_key_path)?;

    if let Some(output_path) = args.get_one::<PathBuf>("output_path") {
        eprintln!("writing unified key JSON to {}", output_path.display());
        unified.write_json_file(output_path)?;
        eprintln!(
            "consider auditing the file's access permissions to ensure its content remains secure"
        );
    } else {
        println!("{}", unified.to_json_string()?);
    }

    Ok(())
}

Trait Implementations

impl Clone for UnifiedApiKey

fn clone(&self) -> UnifiedApiKey

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for UnifiedApiKey

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for UnifiedApiKey

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for UnifiedApiKey

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryFrom<UnifiedApiKey> for ConnectTokenEncoder

type Error = AppleCodesignError

The type returned in the event of a conversion error.

fn try_from(value: UnifiedApiKey) -> Result<Self, Self::Error>

Performs the conversion.