Add option to verify JWT tokens in the HTTP Authorization header

Author: tankyleo

rust/Cargo.lock

@@ -14,10 +14,12 @@
 use api::auth::{AuthResponse, Authorizer};
 use api::error::VssError;
 use async_trait::async_trait;
-use jsonwebtoken::{decode, Algorithm, DecodingKey, Validation};
+use jsonwebtoken::{decode, Algorithm, Validation};
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
 
+pub use jsonwebtoken::DecodingKey;
+
 /// A JWT based authorizer, only allows requests with verified 'JsonWebToken' signed by the given
 /// issuer key.
 ///

rust/auth-impls/src/lib.rs

@@ -5,6 +5,7 @@ edition = "2021"
 
 [dependencies]
 api = { path = "../api" }
+auth-impls = { path = "../auth-impls" }
 impls = { path = "../impls" }
 
 hyper = { version = "1", default-features = false, features = ["server", "http1"] }

rust/server/Cargo.toml

@@ -20,11 +20,14 @@ use hyper_util::rt::TokioIo;
 use crate::vss_service::VssService;
 use api::auth::{Authorizer, NoopAuthorizer};
 use api::kv_store::KvStore;
+use auth_impls::{DecodingKey, JWTAuthorizer};
 use impls::postgres_store::{Certificate, PostgresPlaintextBackend, PostgresTlsBackend};
 use std::sync::Arc;
 
-pub(crate) mod util;
-pub(crate) mod vss_service;
+mod util;
+mod vss_service;
+
+use util::config::{Config, ServerConfig};
 
 fn main() {
 	let args: Vec<String> = std::env::args().collect();
@@ -33,22 +36,21 @@ fn main() {
 		std::process::exit(1);
 	}
 
-	let config = match util::config::load_config(&args[1]) {
-		Ok(cfg) => cfg,
-		Err(e) => {
-			eprintln!("Failed to load configuration: {}", e);
-			std::process::exit(1);
-		},
-	};
-
-	let addr: SocketAddr =
-		match format!("{}:{}", config.server_config.host, config.server_config.port).parse() {
-			Ok(addr) => addr,
+	let Config { server_config: ServerConfig { host, port, rsa_pem_file }, postgresql_config } =
+		match util::config::load_config(&args[1]) {
+			Ok(cfg) => cfg,
 			Err(e) => {
-				eprintln!("Invalid host/port configuration: {}", e);
+				eprintln!("Failed to load configuration: {}", e);
 				std::process::exit(1);
 			},
 		};
+	let addr: SocketAddr = match format!("{}:{}", host, port).parse() {
+		Ok(addr) => addr,
+		Err(e) => {
+			eprintln!("Invalid host/port configuration: {}", e);
+			std::process::exit(1);
+		},
+	};
 
 	let runtime = match tokio::runtime::Builder::new_multi_thread().enable_all().build() {
 		Ok(runtime) => Arc::new(runtime),
@@ -66,9 +68,27 @@ fn main() {
 				std::process::exit(-1);
 			},
 		};
-		let authorizer: Arc<dyn Authorizer> = Arc::new(NoopAuthorizer {});
-		let postgresql_config =
-			config.postgresql_config.expect("PostgreSQLConfig must be defined in config file.");
+
+		let authorizer: Arc<dyn Authorizer> = if let Some(rsa_pem_file) = rsa_pem_file {
+			let rsa_pem = match std::fs::read(rsa_pem_file) {
+				Ok(pem) => pem,
+				Err(e) => {
+					println!("Failed to read RSA public key file: {}", e);
+					std::process::exit(-1);
+				},
+			};
+			let rsa_public_key = match DecodingKey::from_rsa_pem(&rsa_pem) {
+				Ok(pem) => pem,
+				Err(e) => {
+					println!("Failed to parse RSA public key file: {}", e);
+					std::process::exit(-1);
+				},
+			};
+			Arc::new(JWTAuthorizer::new(rsa_public_key).await)
+		} else {
+			Arc::new(NoopAuthorizer {})
+		};
+
 		let endpoint = postgresql_config.to_postgresql_endpoint();
 		let db_name = postgresql_config.database;
 		let store: Arc<dyn KvStore> = if let Some(tls_config) = postgresql_config.tls {
@@ -109,6 +129,7 @@ fn main() {
 			Arc::new(postgres_plaintext_backend)
 		};
 		println!("Connected to PostgreSQL backend with DSN: {}/{}", endpoint, db_name);
+
 		let rest_svc_listener =
 			TcpListener::bind(&addr).await.expect("Failed to bind listening port");
 		println!("Listening for incoming connections on {}", addr);

rust/server/src/main.rs

@@ -3,13 +3,14 @@ use serde::Deserialize;
 #[derive(Deserialize)]
 pub(crate) struct Config {
 	pub(crate) server_config: ServerConfig,
-	pub(crate) postgresql_config: Option<PostgreSQLConfig>,
+	pub(crate) postgresql_config: PostgreSQLConfig,
 }
 
 #[derive(Deserialize)]
 pub(crate) struct ServerConfig {
 	pub(crate) host: String,
 	pub(crate) port: u16,
+	pub(crate) rsa_pem_file: Option<String>,
 }
 
 #[derive(Deserialize)]

rust/server/src/util/config.rs

@@ -1,6 +1,7 @@
 [server_config]
 host = "127.0.0.1"
 port = 8080
+# rsa_pem_file = "rsa_public_key.pem" # Uncomment to verify JWT tokens in the HTTP Authorization header
 
 [postgresql_config]
 username = "postgres"  # Optional in TOML, can be overridden by env var `VSS_POSTGRESQL_USERNAME`