auth for engine api (#3046)

## Issue Addressed

Resolves #3015 

## Proposed Changes

Add JWT token based authentication to engine api requests. The jwt secret key is read from the provided file and is used to sign tokens that are used for authenticated communication with the EL node.

- [x] Interop with geth (synced `merge-devnet-4` with the `merge-kiln-v2` branch on geth)
- [x] Interop with other EL clients (nethermind on `merge-devnet-4`)
- [x] ~Implement `zeroize` for jwt secrets~
- [x] Add auth server tests with `mock_execution_layer`
- [x] Get auth working with the `execution_engine_integration` tests






Co-authored-by: Paul Hauner <paul@paulhauner.com>

beacon_node/execution_layer/src/engines.rs

@@ -21,6 +21,7 @@ enum EngineState {
     Synced,
     Offline,
     Syncing,
+    AuthFailed,
 }
 
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -135,6 +136,7 @@ pub struct Engines<T> {
 pub enum EngineError {
     Offline { id: String },
     Api { id: String, error: EngineApiError },
+    Auth { id: String },
 }
 
 impl<T: EngineApi> Engines<T> {
@@ -226,6 +228,18 @@ impl<T: EngineApi> Engines<T> {
 
                         *state_lock = EngineState::Syncing
                     }
+                    Err(EngineApiError::Auth(err)) => {
+                        if logging.is_enabled() {
+                            warn!(
+                                self.log,
+                                "Failed jwt authorization";
+                                "error" => ?err,
+                                "id" => &engine.id
+                            );
+                        }
+
+                        *state_lock = EngineState::AuthFailed
+                    }
                     Err(e) => {
                         if logging.is_enabled() {
                             warn!(
@@ -295,7 +309,13 @@ impl<T: EngineApi> Engines<T> {
         let mut errors = vec![];
 
         for engine in &self.engines {
-            let engine_synced = *engine.state.read().await == EngineState::Synced;
+            let (engine_synced, engine_auth_failed) = {
+                let state = engine.state.read().await;
+                (
+                    *state == EngineState::Synced,
+                    *state == EngineState::AuthFailed,
+                )
+            };
             if engine_synced {
                 match func(engine).await {
                     Ok(result) => return Ok(result),
@@ -313,6 +333,10 @@ impl<T: EngineApi> Engines<T> {
                         })
                     }
                 }
+            } else if engine_auth_failed {
+                errors.push(EngineError::Auth {
+                    id: engine.id.clone(),
+                })
             } else {
                 errors.push(EngineError::Offline {
                     id: engine.id.clone(),