Server: JWT Signing Algorithm Expansion (svix#994)

## Motivation

See svix#983. The JWT library that we use exposes a number of different
signing algorithms, and it'd be neat to allow people to use some of the
more common ones instead of the default HS256.

## Solution

This PR adds the `JwtSigningConfig` enum to the configuration which
wraps the algorithms exposed by `jwt-simple`. It's a fun, double-layered
enum to allow a fallback shape for backwards compatibility purposes.

The hard part is the deserialization. After that, the signing config
delegates generation and verification calls to whichever kind of key we
have loaded.

The signing config is wrapped in an `Arc` to avoid having many copies of
the key in memory, and also because several of the algorithms are not
`Clone`.

The non-`Default` variants are wrapped in a `Box` to avoid wasting a ton
of space when the `Default` variant is used (which is probably going to
be most of the time).

Finally, the signing config has a custom Debug impl that just spits out
the name of the algorithm in play, to avoid accidentally leaking the
key.

Author: svix-nick

.gitignore

@@ -7,3 +7,4 @@ composer.lock
 
 #IDE
 .vscode
+.idea

server/svix-server/config.default.toml

@@ -18,6 +18,10 @@ listen_address = "0.0.0.0:8071"
 # The JWT secret for authentication - should be secret and securely generated
 # jwt_secret = "8KjzRXrKkd9YFcNyqLSIY8JwiaCeRc6WK4UkMnSW"
 
+# This determines the signature algorithm used when creating JWTs
+# Supported: HS256 (default), HS384, HS512, RS256, RS384, RS512, EdDSA
+# jwt_algorithm = "HS256"
+
 # This determines the type of key that is generated for endpoint secrets by default (when none is set).
 # Supported: hmac256 (default), ed25519
 # Note: this does not affect existing keys, which will continue signing based on the type they were created with.
@@ -101,4 +105,4 @@ worker_enabled = true
 # whitelist_subnets = []
 
 # Maximum number of concurrent worker tasks to spawn (0 is unlimited)
-worker_max_tasks = 500
+worker_max_tasks = 500

server/svix-server/src/cfg.rs

@@ -1,28 +1,18 @@
 // SPDX-FileCopyrightText: © 2022 Svix Authors
 // SPDX-License-Identifier: MIT
 
-use std::{borrow::Cow, collections::HashMap, net::SocketAddr, sync::Arc};
+use std::{borrow::Cow, collections::HashMap, net::SocketAddr, sync::Arc, time::Duration};
 
 use figment::{
     providers::{Env, Format, Toml},
     Figment,
 };
 use ipnet::IpNet;
-use std::time::Duration;
-
-use crate::{core::cryptography::Encryption, core::security::Keys, error::Result};
 use serde::{Deserialize, Deserializer};
 use tracing::Level;
 use validator::{Validate, ValidationError};
 
-fn deserialize_jwt_secret<'de, D>(deserializer: D) -> std::result::Result<Keys, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let buf = String::deserialize(deserializer)?;
-
-    Ok(Keys::new(buf.as_bytes()))
-}
+use crate::{core::cryptography::Encryption, core::security::JwtSigningConfig, error::Result};
 
 fn deserialize_main_secret<'de, D>(deserializer: D) -> std::result::Result<Encryption, D::Error>
 where
@@ -100,9 +90,9 @@ pub struct ConfigurationInner {
     )]
     pub encryption: Encryption,
 
-    /// The JWT secret for authentication - should be secret and securely generated
-    #[serde(deserialize_with = "deserialize_jwt_secret")]
-    pub jwt_secret: Keys,
+    /// Contains the secret and algorithm for signing JWTs
+    #[serde(flatten)]
+    pub jwt_signing_config: Arc<JwtSigningConfig>,
 
     /// This determines the type of key that is generated for endpoint secrets by default (when none is set).
     /// Supported: hmac256 (default), ed25519
@@ -380,6 +370,7 @@ pub fn load() -> Result<Arc<ConfigurationInner>> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::core::security::JWTAlgorithm;
 
     #[test]
     fn test_retry_schedule_parsing() {
@@ -449,4 +440,36 @@ mod tests {
         assert_eq!(cfg.queue_backend(), QueueBackend::Redis("test_a"));
         assert_eq!(cfg.cache_backend(), CacheBackend::Redis("test_b"));
     }
+
+    #[test]
+    fn test_jwt_signing_fallback() {
+        let raw_config = r#"
+jwt_secret = "not_actually_a_secret"
+        "#;
+
+        let actual: JwtSigningConfig = Figment::new()
+            .merge(Toml::string(raw_config))
+            .extract()
+            .unwrap();
+
+        assert!(matches!(actual, JwtSigningConfig::Default { .. }));
+    }
+
+    #[test]
+    fn test_jwt_select_algorithm() {
+        let raw_config = r#"
+jwt_secret = "not_actually_a_secret"
+jwt_algorithm = "HS512"
+        "#;
+
+        let actual: JwtSigningConfig = Figment::new()
+            .merge(Toml::string(raw_config))
+            .extract()
+            .unwrap();
+
+        assert!(matches!(
+            actual,
+            JwtSigningConfig::Advanced(JWTAlgorithm::HS512(_))
+        ));
+    }
 }

server/svix-server/src/core/idempotency.rs

@@ -434,7 +434,7 @@ mod tests {
         // Generate a new token so that keys are unique
         dotenv::dotenv().ok();
         let cfg = crate::cfg::load().unwrap();
-        let token = generate_org_token(&cfg.jwt_secret, OrganizationId::new(None, None))
+        let token = generate_org_token(&cfg.jwt_signing_config, OrganizationId::new(None, None))
             .unwrap()
             .to_string();
 
@@ -536,7 +536,7 @@ mod tests {
         dotenv::dotenv().ok();
         let cfg = crate::cfg::load().unwrap();
 
-        let token = generate_org_token(&cfg.jwt_secret, OrganizationId::new(None, None))
+        let token = generate_org_token(&cfg.jwt_signing_config, OrganizationId::new(None, None))
             .unwrap()
             .to_string();
 
@@ -631,7 +631,7 @@ mod tests {
         // Generate a new token so that keys are unique
         dotenv::dotenv().ok();
         let cfg = crate::cfg::load().unwrap();
-        let token = generate_org_token(&cfg.jwt_secret, OrganizationId::new(None, None))
+        let token = generate_org_token(&cfg.jwt_signing_config, OrganizationId::new(None, None))
             .unwrap()
             .to_string();
 

server/svix-server/src/core/operational_webhooks.rs

@@ -12,15 +12,17 @@ use serde::Serialize;
 use svix::api::{MessageIn, Svix, SvixOptions};
 
 use super::{
-    security::{generate_management_token, Keys},
+    security::generate_management_token,
     types::{
         ApplicationId, ApplicationUid, EndpointId, EndpointUid, MessageAttemptId, MessageId,
         MessageUid, OrganizationId,
     },
 };
+use crate::core::security::JwtSigningConfig;
 use crate::{
     db::models::{endpoint, messageattempt},
-    error::{HttpError, Result},
+    error::{Error, HttpError, Result},
+    location,
 };
 
 /// Sent when an endpoint has been automatically disabled after continuous failures.
@@ -107,13 +109,16 @@ pub enum OperationalWebhook {
 pub type OperationalWebhookSender = Arc<OperationalWebhookSenderInner>;
 
 pub struct OperationalWebhookSenderInner {
-    keys: Keys,
+    signing_config: Arc<JwtSigningConfig>,
     url: Option<String>,
 }
 
 impl OperationalWebhookSenderInner {
-    pub fn new(keys: Keys, url: Option<String>) -> Arc<Self> {
-        Arc::new(Self { keys, url })
+    pub fn new(keys: Arc<JwtSigningConfig>, url: Option<String>) -> Arc<Self> {
+        Arc::new(Self {
+            signing_config: keys,
+            url,
+        })
     }
 
     pub async fn send_operational_webhook(
@@ -126,8 +131,8 @@ impl OperationalWebhookSenderInner {
             None => return Ok(()),
         };
 
-        let op_webhook_token =
-            generate_management_token(&self.keys).expect("Error generating Svix Management token");
+        let op_webhook_token = generate_management_token(&self.signing_config)
+            .map_err(|e| Error::generic(e, location!()))?;
         let svix_api = Svix::new(
             op_webhook_token,
             Some(SvixOptions {