WIP: Example plugin in Rust

examples/fitbit-rs/.cargo/config.toml

@@ -0,0 +1,2 @@
+[build]
+target = "wasm32-unknown-unknown"

examples/fitbit-rs/.gitignore

@@ -0,0 +1,2 @@
+/target
+Cargo.lock

examples/fitbit-rs/Cargo.toml

@@ -0,0 +1,15 @@
+[package]
+name = "fitbit-rs"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+anyhow = "1.0.89"
+base64 = "0.22.1"
+extism-pdk = "1.1.0"
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0"

examples/fitbit-rs/build.sh

@@ -0,0 +1,2 @@
+#!/bin/sh
+cargo build --target wasm32-unknown-unknown

examples/fitbit-rs/src/host_functions.rs

@@ -0,0 +1,11 @@
+use extism_pdk::*;
+
+#[host_fn]
+extern "ExtismHost" {
+    pub fn redirect(url: &str);
+}
+
+#[host_fn]
+extern "ExtismHost" {
+    pub fn notarize(params: &str) -> String;
+}

examples/fitbit-rs/src/lib.rs

@@ -0,0 +1,107 @@
+use std::{collections::HashMap, vec};
+
+use base64::{engine::general_purpose, Engine as _};
+use config::get;
+use extism_pdk::*;
+
+mod types;
+use types::{PluginConfig, RequestConfig, RequestObject, StepConfig};
+mod host_functions;
+use host_functions::{notarize, redirect};
+mod utils;
+use utils::get_cookies_by_host;
+
+#[plugin_fn]
+pub fn config() -> FnResult<Json<PluginConfig<'static>>> {
+    let icon: String = format!(
+        "data:image/png;base64,{}",
+        general_purpose::STANDARD.encode(include_bytes!("../assets/icon.png"))
+    );
+
+    let config = PluginConfig {
+        title: "Fitbit Profile",
+        description: "Notarize ownership of a fitbit profile",
+        steps: vec![
+            StepConfig {
+                title: "Open the Fitbit dashboard",
+                description: Some("Login to your account if you haven't already"),
+                cta: "Go to fitbit.com",
+                action: "start",
+                prover: false,
+            },
+            StepConfig {
+                title: "Notarize fitbit profile",
+                cta: "Notarize",
+                action: "two",
+                prover: true,
+                description: None,
+            },
+        ],
+        host_functions: vec!["redirect", "notarize"],
+        cookies: vec!["www.fitbit.com"],
+        headers: vec!["www.fitbit.com"],
+        requests: vec![RequestObject {
+            url: "https://web-api.fitbit.com/1/user/*/profile.json",
+            method: "GET",
+        }],
+        notary_urls: None,
+        proxy_urls: None,
+        icon,
+    };
+    Ok(Json(config))
+}
+
+#[plugin_fn]
+pub fn start() -> FnResult<Json<bool>> {
+    let dashboard_url = "https://www.fitbit.com/dashboard";
+    let tab_url = get("tabUrl");
+
+    let Ok(Some(url)) = tab_url else {
+        return Ok(Json(false));
+    };
+
+    if url != dashboard_url {
+        unsafe {
+            let _ = redirect(dashboard_url);
+        };
+        return Ok(Json(false));
+    }
+
+    Ok(Json(true))
+}
+
+#[plugin_fn]
+pub fn two() -> FnResult<Json<Option<String>>> {
+    let cookies = get_cookies_by_host("www.fitbit.com")?;
+    log!(LogLevel::Info, "cookies: {cookies:?}");
+
+    let token = cookies
+        .get("oauth_access_token")
+        .ok_or_else(|| Error::msg("oauth_access_token not found"))?;
+    log!(LogLevel::Info, "found token: {token:?}");
+    let bearer_header = format!("Bearer {}", token);
+    let headers: HashMap<&str, &str> = [
+        ("authorization", bearer_header.as_str()),
+        ("Accept-Encoding", "identity"),
+        ("Connection", "close"),
+    ]
+    .into_iter()
+    .collect();
+    let secret_headers = vec![bearer_header.as_str()];
+    let request = RequestConfig {
+        url: "https://web-api.fitbit.com/1/user/4G7WVQ/profile.json",
+        method: "GET",
+        headers,
+        secret_headers,
+    };
+
+    let request_json = serde_json::to_string(&request)?;
+    log!(LogLevel::Info, "request: {:?}", &request_json);
+    let id = unsafe {
+        let id = notarize(&request_json);
+        log!(LogLevel::Info, "Notarization result: {:?}", id);
+        id?
+    };
+
+    return Ok(Json(Some(id)));
+}

examples/fitbit-rs/src/types.rs

@@ -0,0 +1,52 @@
+use std::collections::HashMap;
+
+use extism_pdk::*;
+use serde::{Deserialize, Serialize};
+
+#[derive(FromBytes, Deserialize, PartialEq, Debug, Serialize, ToBytes)]
+#[serde(rename_all = "camelCase")]
+#[encoding(Json)]
+pub struct PluginConfig<'a> {
+    pub title: &'a str,
+    pub description: &'a str,
+    pub icon: String,
+    pub steps: Vec<StepConfig<'a>>,
+    pub host_functions: Vec<&'a str>,
+    pub cookies: Vec<&'a str>,
+    pub headers: Vec<&'a str>,
+    pub requests: Vec<RequestObject<'a>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub notary_urls: Option<Vec<&'a str>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub proxy_urls: Option<Vec<&'a str>>,
+}
+
+#[derive(FromBytes, Deserialize, PartialEq, Debug, Serialize, ToBytes)]
+#[serde(rename_all = "camelCase")]
+#[encoding(Json)]
+pub struct StepConfig<'a> {
+    pub title: &'a str,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<&'a str>,
+    pub cta: &'a str,
+    pub action: &'a str,
+    pub prover: bool,
+}
+
+#[derive(FromBytes, Deserialize, PartialEq, Debug, Serialize, ToBytes)]
+#[serde(rename_all = "camelCase")]
+#[encoding(Json)]
+pub struct RequestObject<'a> {
+    pub url: &'a str,
+    pub method: &'a str,
+}
+
+#[derive(FromBytes, Deserialize, PartialEq, Debug, Serialize, ToBytes)]
+#[serde(rename_all = "camelCase")]
+#[encoding(Json)]
+pub struct RequestConfig<'a> {
+    pub url: &'a str,
+    pub method: &'a str,
+    pub headers: HashMap<&'a str, &'a str>,
+    pub secret_headers: Vec<&'a str>,
+}

examples/fitbit-rs/src/utils.rs

@@ -0,0 +1,19 @@
+use std::collections::HashMap;
+
+use anyhow::Context;
+use config::get;
+use extism_pdk::*;
+
+pub fn get_cookies_by_host(hostname: &str) -> Result<HashMap<String, String>, Error> {
+    // Get Cookies via Extism
+    let cookies_json: String = get("cookies")?.context("No cookies found in the configuration.")?;
+
+    // Parse the JSON string directly into a HashMap
+    let cookies: HashMap<String, HashMap<String, String>> = serde_json::from_str(&cookies_json)?;
+
+    // Attempt to find the hostname in the map
+    cookies
+        .get(hostname)
+        .cloned()
+        .context(format!("Cannot find cookies for {}", hostname))
+}

examples/fitbit-rs/testing.md

@@ -0,0 +1,9 @@
+# Testing
+
+1. start notary server (**TLS off** for local testing, check version!)
+2. Start proxy server:
+```
+websocat --binary -v ws-l:0.0.0.0:55688 tcp:web-api.fitbit.com:443
+```
+3. `cargo build --release`
+4. Load plugin in browser extension