Struct zitadel::credentials::Application

pub struct Application { /* private fields */ }

Application for ZITADEL. An application is an OIDC application type that allows a backend (for example an API for some single page application) to check if sent credentials from a client are valid or not.

When using ZITADEL to authenticate a user against some backend, the application provides the means to access the introspection endpoint of ZITADEL. It uses OIDC Introspection, defined in RFC7662.

To create an application json, head over to your ZITADEL console and execute the following steps:

• Create a project
• Create an API application
• Create a “key” inside the application to create and download the JWT profile

Implementations

impl Application

pub fn load_from_file(file_path: &str) -> Result<Self, ApplicationError>

Load an Application from a JSON file at a specific filepath.

Errors

This function may return an error when read_to_string returns an error. Further, an error may occur during the deserialization of load_from_json.

Example

use zitadel::credentials::Application;
let application = Application::load_from_file("./my_json_key.json")?;
println!("{:#?}", application);

pub fn load_from_json(json: &str) -> Result<Self, ApplicationError>

Load an Application from a JSON string.

Errors

This method may fail if the deserialization does fail. Such an error can occur if the JSON is not formatted properly.

Example

use zitadel::credentials::Application;
let application = Application::load_from_json(r#"{"keyId": "1337", "clientId": "testing", "userId": "42", "key": "foobar", "appId": "myapp"}"#)?;
println!("{:#?}", application);

pub fn create_signed_jwt( &self, audience: &str ) -> Result<String, ApplicationError>

Create a (RSA) signed JWT token that is used to authenticate the application against ZITADEL.

When using OAuth 2.0 Token Introspection, in combination with JWT Profile authentication, the API in question must present a signed JWT token to ZITADEL to authenticate itself. This is not the case when basic authentication is used. The signed JWT token is used as client assertion when using introspection.

Prosa code to check if an incoming access token is valid

let token = get_token_from_request();
let application = Application::load_from_file("./my_json_key.json")?;
let jwt = application.create_signed_jwt("https://my-zitadel-instance.cloud");
let request = Request {
  url: introspection_endpoint,
  body: {
    client_assertion_type: "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
    client_assertion: jwt,
    token: token,
  },
  header: { content-type: "application/x-www-form-urlencoded" },
};
let response = send_and_parse_request(request);
println!("{:#?}", response.active);

Trait Implementations

impl Clone for Application

fn clone(&self) -> Application

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Application

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Application

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Application

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

where __S: Serializer,

Serialize this value into the given Serde serializer.