@multiplatform.one/wallet 7.7.2

package/src/hooks/useSiweKeycloak.ts

@@ -0,0 +1,23 @@
+import { useModal, useSIWE } from "@multiplatform.one/web3/connectkit";
+import { useContext } from "react";
+import { useAccount } from "wagmi";
+import { SiweKeycloakContext } from "./context";
+
+export function useSiweKeycloak() {
+  const { addresses } = useAccount();
+  const { signOut } = useSIWE();
+  const { openSIWE, openSwitchNetworks, openOnboarding, openAbout, openProfile } = useModal();
+  const { keycloak } = useContext(SiweKeycloakContext);
+  return {
+    signOut,
+    openSIWE,
+    openSwitchNetworks,
+    openOnboarding,
+    openAbout,
+    openProfile,
+    keycloak,
+    connect() {
+      if (!addresses?.length) openProfile();
+    },
+  };
+}

package/src/index.ts

@@ -0,0 +1,127 @@
+import type { GetWalletClientData } from "@wagmi/core/query";
+import type { Address } from "viem";
+import type { UseClientReturnType } from "wagmi";
+import type { RenderOptions } from "./render";
+import { render } from "./render";
+import type { KeycloakConfig } from "./types";
+import { createMessage, getNonce } from "./util";
+export interface SiweKeycloakOptions extends RenderOptions {}
+
+export class SiweKeycloak {
+  private _walletClientResolvers: ((value: null) => void)[] = [];
+
+  addresses: readonly [Address, ...Address[]] | readonly Address[] = [];
+  client?: UseClientReturnType;
+  connect?: () => Promise<void>;
+  keycloakConfig: KeycloakConfig;
+  openAbout?: () => any;
+  openOnboarding?: () => any;
+  openProfile?: () => Promise<void>;
+  openSIWE?: () => Promise<void>;
+  openSwitchNetworks?: () => any;
+  signOut?: () => any;
+  walletClient?: GetWalletClientData<any, any>;
+
+  constructor(
+    options?: Omit<
+      SiweKeycloakOptions,
+      | "onSetClient"
+      | "onSetConnect"
+      | "onSetOpenAbout"
+      | "onSetOpenOnboarding"
+      | "onSetOpenProfile"
+      | "onSetOpenSIWE"
+      | "onSetOpenSwitchNetworks"
+      | "onSetSignOut"
+      | "onSetWalletClient"
+    >,
+  ) {
+    render({
+      ...options,
+      onAddresses: (addresses) => {
+        this.addresses = addresses;
+        if (!addresses.length) this.walletClient = undefined;
+        options?.onAddresses?.(addresses);
+      },
+      onSetOpenAbout: (openAbout) => {
+        this.openAbout = openAbout;
+      },
+      onSetOpenOnboarding: (openOnboarding) => {
+        this.openOnboarding = openOnboarding;
+      },
+      onSetOpenProfile: (openProfile) => {
+        this.openProfile = this._asyncTrigger(openProfile);
+      },
+      onSetOpenSIWE: (openSIWE) => {
+        this.openSIWE = this._asyncTrigger(openSIWE);
+      },
+      onSetConnect: (connect) => {
+        this.connect = this._asyncTrigger(connect);
+      },
+      onSetOpenSwitchNetworks: (openSwitchNetworks) => {
+        this.openSwitchNetworks = openSwitchNetworks;
+      },
+      onSetSignOut: (signOut) => {
+        this.signOut = signOut;
+      },
+      onSetClient: (client) => {
+        this.client = client;
+      },
+      onSetWalletClient: (walletClient) => {
+        this.walletClient = walletClient;
+        if (walletClient) {
+          this._walletClientResolvers.forEach((resolve) => resolve(null));
+          this._walletClientResolvers = [];
+        }
+      },
+    });
+    this.keycloakConfig = {
+      ...options?.keycloak,
+      ...(typeof options?.keycloak?.baseUrl !== "undefined"
+        ? { baseUrl: options?.keycloak?.baseUrl }
+        : {
+            baseUrl: "http://localhost:8080",
+          }),
+      ...(typeof options?.keycloak?.clientId !== "undefined"
+        ? { clientId: options?.keycloak?.clientId }
+        : { clientId: "app" }),
+      ...(typeof options?.keycloak?.realm !== "undefined"
+        ? { realm: options?.keycloak?.realm }
+        : { realm: "main" }),
+      ...(typeof options?.keycloak?.scope !== "undefined"
+        ? { scope: options?.keycloak?.scope }
+        : { scope: [] }),
+    };
+  }
+
+  private _asyncTrigger(trigger: (...args: any[]) => void) {
+    return async (...args: any[]) => {
+      await new Promise((resolve, reject) => {
+        try {
+          this._walletClientResolvers.push(resolve);
+          trigger(...args);
+          if (this.walletClient) return resolve(null);
+        } catch (err) {
+          reject(err);
+        }
+      });
+    };
+  }
+
+  async getNonce() {
+    return getNonce(
+      `${this.keycloakConfig.baseUrl}/realms/${this.keycloakConfig.realm || "main"}/siwe`,
+    );
+  }
+
+  async createMessage(address: Address) {
+    if (!this.client?.chain.id) return;
+    const nonce = await this.getNonce();
+    return createMessage(nonce, address, this.client.chain.id);
+  }
+}
+
+export * from "./SiweKeycloakProvider";
+export * from "./hooks";
+export * from "./types";
+export * from "./util";

package/src/main/java/com/bitspur/keycloak/siwe/Errors.java

@@ -0,0 +1,21 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/Errors.java
+ * Project: authenticators
+ * File Created: 26-03-2022 13:20:05
+ * Author: Clay Risser
+ * -----
+ * Last Modified: 10-08-2023 16:34:52
+ * Modified By: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022
+ */
+
+package com.bitspur.keycloak.siwe;
+
+public class Errors {
+  public static final class SiweKeycloakException extends Exception {
+    public SiweKeycloakException(String msg) {
+      super(msg);
+    }
+  }
+}

package/src/main/java/com/bitspur/keycloak/siwe/LiteAuthenticationService.java

@@ -0,0 +1,167 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/LiteAuthenticationService.java
+ * Project: @risserlabs/keycloak-avatar-client
+ * File Created: 04-08-2022 13:44:07
+ * Author: Clay Risser
+ * -----
+ * Last Modified: 12-02-2024 12:47:58
+ * Modified By: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022
+ */
+
+package com.bitspur.keycloak.siwe;
+
+import jakarta.ws.rs.core.HttpHeaders;
+
+import org.jboss.logging.Logger;
+import org.keycloak.TokenVerifier;
+import org.keycloak.common.ClientConnection;
+import org.keycloak.common.VerificationException;
+import org.keycloak.common.constants.ServiceAccountConstants;
+import org.keycloak.crypto.SignatureProvider;
+import org.keycloak.crypto.SignatureVerifierContext;
+import org.keycloak.models.AuthenticatedClientSessionModel;
+import org.keycloak.models.ClientModel;
+import org.keycloak.models.KeycloakSession;
+import org.keycloak.models.RealmModel;
+import org.keycloak.models.UserModel;
+import org.keycloak.models.UserSessionModel;
+import org.keycloak.models.utils.KeycloakModelUtils;
+import org.keycloak.protocol.oidc.OIDCLoginProtocol;
+import org.keycloak.protocol.oidc.TokenManager.NotBeforeCheck;
+import org.keycloak.protocol.oidc.TokenManager;
+import org.keycloak.representations.AccessToken;
+import org.keycloak.services.Urls;
+import org.keycloak.services.managers.AppAuthManager;
+import org.keycloak.services.managers.AuthenticationManager.AuthResult;
+import org.keycloak.services.managers.AuthenticationManager;
+import org.keycloak.services.managers.UserSessionCrossDCManager;
+import org.keycloak.sessions.AuthenticationSessionModel;
+import org.keycloak.sessions.RootAuthenticationSessionModel;
+
+public class LiteAuthenticationService {
+  private KeycloakSession session;
+  private AppAuthManager appAuthManager;
+  private Logger logger = Logger.getLogger(LiteAuthenticationService.class);
+
+  public LiteAuthenticationService(KeycloakSession session) {
+    this.session = session;
+    this.appAuthManager = new AppAuthManager();
+  }
+
+  public AuthResult resolveAuthentication(HttpHeaders headers, ClientConnection clientConnection) {
+    RealmModel realm = session.getContext().getRealm();
+    AuthResult authResult = this.appAuthManager.authenticateIdentityCookie(session,
+        realm);
+    if (authResult != null) {
+      return authResult;
+    }
+    AppAuthManager.AuthHeader authHeader = AppAuthManager.extractAuthorizationHeaderTokenOrReturnNull(headers);
+    if (authHeader == null) {
+      return null;
+    }
+    String accessToken = authHeader.getToken();
+    AccessToken token;
+    ClientModel client;
+    try {
+      TokenVerifier<AccessToken> verifier = TokenVerifier.create(accessToken, AccessToken.class).withDefaultChecks()
+          .realmUrl(Urls.realmIssuer(session.getContext().getUri().getBaseUri(), realm.getName()));
+      SignatureVerifierContext verifierContext = session
+          .getProvider(SignatureProvider.class, verifier.getHeader().getAlgorithm().name())
+          .verifier(verifier.getHeader().getKeyId());
+      verifier.verifierContext(verifierContext);
+      token = verifier.verify().getToken();
+      if (token == null) {
+        return null;
+      }
+      try {
+        client = realm.getClientByClientId(token.getIssuedFor());
+      } catch (Exception e) {
+        logger.error(e);
+        return null;
+      }
+      if (client == null) {
+        return null;
+      }
+      TokenVerifier.createWithoutSignature(token)
+          .withChecks(NotBeforeCheck.forModel(client), new TokenManager.TokenRevocationCheck(session))
+          .verify();
+    } catch (VerificationException e) {
+      return null;
+    }
+    session.getContext().setClient(client);
+    if (!client.isEnabled()) {
+      return null;
+    }
+    UserSessionModel userSession = findValidSession(token, client, clientConnection);
+    if (userSession == null) {
+      return null;
+    }
+    UserModel user = userSession.getUser();
+    if (user == null) {
+      return null;
+    }
+    return new AuthResult(user, userSession, token, client);
+  }
+
+  private UserSessionModel findValidSession(AccessToken token, ClientModel clientModel,
+      ClientConnection clientConnection) {
+    RealmModel realm = session.getContext().getRealm();
+    if (token.getSessionState() == null) {
+      return createTransientSessionForClient(token, clientModel, clientConnection);
+    }
+    UserSessionModel userSession = new UserSessionCrossDCManager(session).getUserSessionWithClient(realm,
+        token.getSessionState(), false, clientModel.getId());
+    UserSessionModel offlineUserSession = null;
+    if (AuthenticationManager.isSessionValid(realm, userSession)) {
+      if (!checkTokenIssuedAt(token, userSession, clientModel)) {
+        return null;
+      }
+      return userSession;
+    } else {
+      offlineUserSession = new UserSessionCrossDCManager(session).getUserSessionWithClient(realm,
+          token.getSessionState(), true, clientModel.getId());
+      if (AuthenticationManager.isSessionValid(realm, offlineUserSession)) {
+        if (!checkTokenIssuedAt(token, offlineUserSession, clientModel)) {
+          return null;
+        }
+        return offlineUserSession;
+      }
+    }
+    return null;
+  }
+
+  private UserSessionModel createTransientSessionForClient(AccessToken token, ClientModel client,
+      ClientConnection clientConnection) {
+    RealmModel realm = session.getContext().getRealm();
+    UserModel user = TokenManager.lookupUserFromStatelessToken(session, realm, token);
+    if (user == null) {
+      return null;
+    }
+    UserSessionModel userSession = session.sessions().createUserSession(KeycloakModelUtils.generateId(), realm, user,
+        user.getUsername(), clientConnection.getRemoteAddr(),
+        ServiceAccountConstants.CLIENT_AUTH, false, null, null, UserSessionModel.SessionPersistenceState.TRANSIENT);
+    RootAuthenticationSessionModel rootAuthSession = session.authenticationSessions()
+        .createRootAuthenticationSession(realm);
+    AuthenticationSessionModel authSession = rootAuthSession.createAuthenticationSession(client);
+    authSession.setAuthenticatedUser(userSession.getUser());
+    authSession.setProtocol(OIDCLoginProtocol.LOGIN_PROTOCOL);
+    authSession.setClientNote(OIDCLoginProtocol.ISSUER,
+        Urls.realmIssuer(session.getContext().getUri().getBaseUri(), realm.getName()));
+    AuthenticationManager.setClientScopesInSession(session, authSession);
+    TokenManager.attachAuthenticationSession(session, userSession, authSession);
+    return userSession;
+  }
+
+  private boolean checkTokenIssuedAt(AccessToken token, UserSessionModel userSession, ClientModel client) {
+    if (token.isIssuedBeforeSessionStart(userSession.getStarted())) {
+      return false;
+    }
+    AuthenticatedClientSessionModel clientSession = userSession.getAuthenticatedClientSessionByClient(client.getId());
+    if (token.isIssuedBeforeSessionStart(clientSession.getStarted())) {
+      return false;
+    }
+    return true;
+  }
+}

package/src/main/java/com/bitspur/keycloak/siwe/SiweCredentials.java

@@ -0,0 +1,36 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/SiweCredentials.java
+ * Project: authenticators
+ * File Created: 27-03-2022 13:41:10
+ * Author: Clay Risser
+ * -----
+ * Last Modified: 09-01-2025 22:52:35
+ * Modified By: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022
+ */
+
+package com.bitspur.keycloak.siwe;
+
+import com.bitspur.keycloak.siwe.Errors.SiweKeycloakException;
+import com.moonstoneid.siwe.SiweMessage.Parser;
+import com.moonstoneid.siwe.SiweMessage;
+import com.moonstoneid.siwe.error.SiweException;
+import java.util.Base64;
+
+public class SiweCredentials {
+  private static final Base64.Decoder decoder = Base64.getDecoder();
+
+  public SiweMessage message;
+
+  public String signature;
+
+  public SiweCredentials(String username, String password) throws SiweKeycloakException {
+    this.signature = username;
+    try {
+      this.message = new Parser().parse(new String(decoder.decode(password)));
+    } catch (SiweException e) {
+      throw new SiweKeycloakException(e.getMessage());
+    }
+  }
+}

package/src/main/java/com/bitspur/keycloak/siwe/SiweSession.java

@@ -0,0 +1,36 @@
+/**
+ * File: /src/main/java/com/bitspur/keycloak/siwe/SiweSession.java
+ * Project: siwe-keycloak
+ * File Created: 10-04-2023 23:23:57
+ * Author: Clay Risser
+ * -----
+ * Last Modified: 10-08-2023 16:34:52
+ * Modified By: Clay Risser
+ * -----
+ * BitSpur (c) Copyright 2022 - 2023
+ */
+
+package com.bitspur.keycloak.siwe;
+
+public class SiweSession {
+  private String key;
+
+  private String nonce;
+
+  public SiweSession(String key, String nonce) {
+    this.key = key;
+    this.nonce = nonce;
+  }
+
+  public String getSessionKey() {
+    return this.key;
+  }
+
+  public String getKey() {
+    return this.key;
+  }
+
+  public String getNonce() {
+    return this.nonce;
+  }
+}