1

我们有一个使用 Vue3 的前端应用程序和一个使用 nodejs+express 的后端。

我们正在努力做到这一点，一旦前端应用程序被 keycloak 授权，它就可以将不记名令牌传递给后端（在同一领域中也受到 keycloak 的保护），以进行 API 调用。

谁能建议我们应该如何做到这一点？

跟随是我们正在尝试和看到的结果。

返回的错误只是“拒绝访问”，没有其他详细信息运行调试器，我们看到函数中抛出了“无效令牌（错误的受众）”错误GrantManager.validateToken（不幸的是，它没有冒泡）。

在webapp启动中我们初始化axios如下，将bearer token传递给后端服务器

  const axiosConfig: AxiosRequestConfig = {
    baseURL: 'http://someurl'
  };
  api = axios.create(axiosConfig);

  // include keycloak token when communicating with API server
  api.interceptors.request.use(
    (config) => {
      if (app.config.globalProperties.$keycloak) {
        const keycloak = app.config.globalProperties.$keycloak;
        const token = keycloak.token as string;
        const auth = 'Authorization';
        if (token && config.headers) {
          config.headers[auth] = `Bearer ${token}`;
        }
      }

      return config;
    }
  );

  app.config.globalProperties.$api = api;

在后端，在中间件初始化期间：

const keycloak = new Keycloak({});
app.keycloak = keycloak;

app.use(keycloak.middleware({
  logout: '/logout',
  admin: '/'
}));

然后在保护端点时：

const keycloakJson = keystore.get('keycloak');
const keycloak = new KeycloakConnect ({
  cookies: false
}, keycloakJson);
router.use('/api', keycloak.protect('realm:staff'), apiRoutes);

我们在 Keycloak 中配置了两个客户端：

  • 应用程序前端，设置为使用访问类型“公共”
  • 应用服务器，设置为使用访问类型“承载令牌”

尝试使用$keycloak.token会给我们“无效的令牌（错误的受众）”错误，但如果我们尝试使用$keycloak.idToken，那么我们会得到“无效的令牌（错误的类型）”

在第一种情况下，它将token.content.aud值“帐户”与 clientId 进行比较app-server。在第二种情况下，它将token.content.typ值 'ID' 与预期类型的​​ 'Bearer' 进行比较。

4

1 回答 1

0

在与另一个项目的开发人员讨论后，事实证明我的方法在服务器上是错误的，这keycloak-connect也是该工作的错误工具。原因keycloak-connect是想要进行自己的身份验证流程，因为前端令牌不兼容。

建议的方法是获取标头中提供的不记名令牌，并将 jwt-uri 用于我的 keycloak 领域来验证令牌，然后使用令牌中我需要的任何数据。

requireApiAuthentication以下是我用来保护端点的功能的早期实现（它有效，但需要改进） ：

import jwksClient from 'jwks-rsa';
import jwt, { Secret, GetPublicKeyOrSecret } from 'jsonwebtoken';

// promisify jwt.verify, since it doesn't do promises
async function jwtVerify (token: string, secretOrPublicKey: Secret | GetPublicKeyOrSecret): Promise<any> {
    return new Promise<any>((resolve, reject) => {
        jwt.verify(token, secretOrPublicKey, (err: any, decoded: object | undefined) => {
            if (err) {
                reject(err);
            } else {
                resolve(decoded);
            }
        });
    });
}

function requireApiAuthentication (requiredRole: string) {

    // TODO build jwksUri based on available keycloak configuration;
    const baseUrl = '...';
    const realm = '...';

    const client = jwksClient({
        jwksUri: `${baseUrl}/realms/${realm}/protocol/openid-connect/certs`
    });

    function getKey (header, callback) {
        client.getSigningKey(header.kid, (err: any, key: Record<string, any>) => {
            const signingKey = key.publicKey || key.rsaPublicKey;
            callback(null, signingKey);
        });
    }

    return async (req: Request, res: Response, next: NextFunction) => {
        const authorization = req.headers.authorization;
        if (authorization && authorization.toLowerCase().startsWith('bearer ')) {
            const token = authorization.split(' ')[1];
            const tokenDecoded = await jwtVerify(token, getKey);

            if (tokenDecoded.realm_access && tokenDecoded.realm_access.roles) {
                const roles = tokenDecoded.realm_access.roles;
                if (roles.indexOf(requiredRole) > -1) {
                    next();
                    return;
                }
            }
        }

        next(new Error('Unauthorized'));
    };
}

然后按如下方式使用：

router.use('/api', requireApiAuthentication('staff'), apiRoutes);
于 2021-12-14T18:43:12.813 回答