@alauda-fe/common
Version:
Alauda frontend team common codes.
186 lines • 26.9 kB
JavaScript
import { HttpResponse, } from '@angular/common/http';
import { Inject, Injectable, isDevMode, Optional } from '@angular/core';
import aes from 'crypto-js/aes';
import encBase64 from 'crypto-js/enc-base64';
import encHex from 'crypto-js/enc-hex';
import encUtf8 from 'crypto-js/enc-utf8';
import formatHex from 'crypto-js/format-hex';
import hmacSha256 from 'crypto-js/hmac-sha256';
import modeCtr from 'crypto-js/mode-ctr';
// cspell: disable-next-line
import noPadding from 'crypto-js/pad-nopadding';
import { catchError, map, of, tap, throwError } from 'rxjs';
import { v4 } from 'uuid';
import { CRYPTO_HEADER_KEY, CRYPTO_KEY, CRYPTO_RANDOM_HEADER_KEY, CRYPTO_TYPE, TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS, } from '../core/constants/public-api';
import { SEARCH_URL_PREFIX } from './k8s-api.service';
import * as i0 from "@angular/core";
const defaultEnableUrlRegexps = [
/\/api\/v1\/(.*\/)?secrets/i,
/\/apis\/platform.tkestack.io\/v1\/clusters(\/.*)?/i,
/\/apis\/platform.tkestack.io\/v1\/clustercredentials/i,
/\/apis\/platform.tkestack.io\/v1\/machines/i,
];
const isStandaloneApi = (url) => {
let path = url.match(/((https?:)?\/\/)?[^/]*(\/[^?]*)/)?.[3];
if (path && isDevMode()) {
// 开发模式下，需要把APIGateway移除
// 正常情况不会将前缀设置成多层路径，所以直接移除第一层路径
path = path.replace(/^\/[^/]*/, '');
}
const regex = new RegExp(`^(${SEARCH_URL_PREFIX})?/(apis?|kubernetes)/`);
return path && regex.test(path);
};
const defaultEnable = (req, extra = []) => {
return [...defaultEnableUrlRegexps, ...extra].some(regexp => regexp.test(req.url) && isStandaloneApi(req.url));
};
// 可选的 api 加密拦截器，目前仅支持以/api /apis /kubernetes/ 开头的API
// 后端方案：https://confluence.alauda.cn/pages/viewpage.action?pageId=163054340
// 如果使用 http 则通过设置 headers 来选择加密策略，key 为 CRYPTO_HEADER_KEY
// 如果使用 k8sApi 则通过 crypto 来选择加密策略
// 可以通过 TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS 注入默认的开启加密匹配正则
export class CryptoInterceptorService {
constructor(extraUrlRegexps) {
this.extraUrlRegexps = extraUrlRegexps;
}
factoryContentType(req) {
if (!req.headers.has('Content-Type')) {
const detectedType = req.detectContentTypeHeader();
if (detectedType !== null) {
req = req.clone({
headers: req.headers.set('Content-Type', detectedType),
});
}
}
return req;
}
encryptPayload(req) {
if (req.headers.get(CRYPTO_HEADER_KEY) && req.body) {
let bodyStr = '';
// 只对json和字符串类型的payload加密
if (typeof req.body === 'string') {
bodyStr = req.body;
}
else {
try {
bodyStr = JSON.stringify(req.body);
}
catch { }
}
if (bodyStr) {
// 将 angular 自动识别的逻辑加到这里来，避免加密后被统一设成 text
req = this.factoryContentType(req);
const random = v4().replaceAll('-', '');
req = req.clone({
headers: req.headers.set(CRYPTO_RANDOM_HEADER_KEY, random),
body: encrypt(bodyStr, random),
});
}
}
return req;
}
factoryReq(req) {
if (!req.headers.get(CRYPTO_HEADER_KEY) &&
defaultEnable(req, this.extraUrlRegexps)) {
req = req.clone({
headers: req.headers.set(CRYPTO_HEADER_KEY, CRYPTO_TYPE.Enable),
});
}
req = this.encryptPayload(req);
return req;
}
/**
* 实现方案：
* 1. 请求和响应处理分开处理，在请求的header上加上加密标识，根据返回的响应header处理对应的加密策略，而不是使用请求时使用的策略。这样能规避服务端的主动加密策略（前端没有使用加密）
* 2. 如果解密失败，将不做任何处理，原样返回，因为理论上解密不应该失败，如果失败可能是不需要解密，最主要的是返回解密失败的信息比原样返回对业务来说更没意义
*/
intercept(req, next) {
req = this.factoryReq(req);
// 当是 progress ，例如 watch 场景的变更，不能获取 responseHeader，所以需要先在其他状态及时记录 responseHeader
let responseHeader;
return next.handle(req).pipe(tap((event) => {
responseHeader = event.headers || responseHeader;
}), map(event => {
const random = responseHeader?.get(CRYPTO_RANDOM_HEADER_KEY);
// 如果不是正常的响应
if (!(event instanceof HttpResponse)) {
if (event.type === 3 && random) {
const progressEvent = event;
try {
progressEvent.partialText = decrypt(random, progressEvent.partialText);
}
catch { }
return progressEvent;
}
return event;
}
// 如果是正常的响应
if (!random || !event.body) {
return event;
}
try {
return event.clone({
body: decrypt(random, event.body),
});
}
catch { }
return event;
}), catchError((err) => {
// 加密后返回的是字符串，所以如果请求的是json则一定是error的（如果 responseType 是 json，则无论响应的 content-type 是不是 json 都按照json解析）
const random = err?.headers?.get(CRYPTO_RANDOM_HEADER_KEY);
if (random &&
req.responseType === 'json' &&
typeof err.error.text === 'string') {
try {
// 如果存在加密标识且请求的是json，则这个错误基本上就是因为解析json导致的，所以尝试解密后进行json解析
const json = JSON.parse(decrypt(random, err.error.text));
// 如果解析成功则其就应该是一个正常的返回，所以生成一个正常的 HttpResponse
return of(new HttpResponse({
body: json,
status: err.status,
headers: err.headers,
statusText: err.statusText,
url: err.url,
}));
}
catch {
return throwError(() => err);
}
}
return throwError(() => err);
}));
}
static { this.ɵfac = function CryptoInterceptorService_Factory(t) { return new (t || CryptoInterceptorService)(i0.ɵɵinject(TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS, 8)); }; }
static { this.ɵprov = /*@__PURE__*/ i0.ɵɵdefineInjectable({ token: CryptoInterceptorService, factory: CryptoInterceptorService.ɵfac }); }
}
(() => { (typeof ngDevMode === "undefined" || ngDevMode) && i0.ɵsetClassMetadata(CryptoInterceptorService, [{
type: Injectable
}], () => [{ type: undefined, decorators: [{
type: Optional
}, {
type: Inject,
args: [TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS]
}] }], null); })();
function decrypt(random, content) {
// 先用 hex 把 content 解密
const contentHex = encHex.parse(content.replaceAll('\n', ''));
// 随机数经过HMAC-sha256后取前端16字节，HMAC密钥为字符串“alauda”
const key = encHex.parse(hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32));
return aes
.decrypt(encBase64.stringify(contentHex), key, {
iv: key,
mode: modeCtr,
padding: noPadding,
})
.toString(encUtf8);
}
function encrypt(content, random) {
const key = encHex.parse(hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32));
return aes
.encrypt(content, key, {
iv: key,
mode: modeCtr,
padding: noPadding,
})
.toString(formatHex);
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"crypto.interceptor.js","sourceRoot":"","sources":["../../../../../libs/common/src/api/crypto.interceptor.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  HttpDownloadProgressEvent,\n  HttpErrorResponse,\n  HttpEvent,\n  HttpHandler,\n  HttpHeaders,\n  HttpInterceptor,\n  HttpRequest,\n  HttpResponse,\n} from '@angular/common/http';\nimport { Inject, Injectable, isDevMode, Optional } from '@angular/core';\nimport aes from 'crypto-js/aes';\nimport encBase64 from 'crypto-js/enc-base64';\nimport encHex from 'crypto-js/enc-hex';\nimport encUtf8 from 'crypto-js/enc-utf8';\nimport formatHex from 'crypto-js/format-hex';\nimport hmacSha256 from 'crypto-js/hmac-sha256';\nimport modeCtr from 'crypto-js/mode-ctr';\n// cspell: disable-next-line\nimport noPadding from 'crypto-js/pad-nopadding';\nimport { catchError, map, Observable, of, tap, throwError } from 'rxjs';\nimport { v4 } from 'uuid';\n\nimport {\n  CRYPTO_HEADER_KEY,\n  CRYPTO_KEY,\n  CRYPTO_RANDOM_HEADER_KEY,\n  CRYPTO_TYPE,\n  TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS,\n} from '../core/constants/public-api';\n\nimport { SEARCH_URL_PREFIX } from './k8s-api.service';\n\nconst defaultEnableUrlRegexps: RegExp[] = [\n  /\\/api\\/v1\\/(.*\\/)?secrets/i,\n  /\\/apis\\/platform.tkestack.io\\/v1\\/clusters(\\/.*)?/i,\n  /\\/apis\\/platform.tkestack.io\\/v1\\/clustercredentials/i,\n  /\\/apis\\/platform.tkestack.io\\/v1\\/machines/i,\n];\nconst isStandaloneApi = (url: string) => {\n  let path = url.match(/((https?:)?\\/\\/)?[^/]*(\\/[^?]*)/)?.[3];\n  if (path && isDevMode()) {\n    // 开发模式下，需要把APIGateway移除\n    // 正常情况不会将前缀设置成多层路径，所以直接移除第一层路径\n    path = path.replace(/^\\/[^/]*/, '');\n  }\n  const regex = new RegExp(`^(${SEARCH_URL_PREFIX})?/(apis?|kubernetes)/`);\n  return path && regex.test(path);\n};\nconst defaultEnable = (req: HttpRequest<unknown>, extra: RegExp[] = []) => {\n  return [...defaultEnableUrlRegexps, ...extra].some(\n    regexp => regexp.test(req.url) && isStandaloneApi(req.url),\n  );\n};\n\n// 可选的 api 加密拦截器，目前仅支持以/api /apis /kubernetes/ 开头的API\n// 后端方案：https://confluence.alauda.cn/pages/viewpage.action?pageId=163054340\n// 如果使用 http 则通过设置 headers 来选择加密策略，key 为 CRYPTO_HEADER_KEY\n// 如果使用 k8sApi 则通过 crypto 来选择加密策略\n// 可以通过 TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS 注入默认的开启加密匹配正则\n@Injectable()\nexport class CryptoInterceptorService implements HttpInterceptor {\n  constructor(\n    @Optional()\n    @Inject(TOKEN_CRYPTO_INTERCEPTOR_URL_REGEXPS)\n    private readonly extraUrlRegexps: RegExp[],\n  ) {}\n\n  private factoryContentType(req: HttpRequest<unknown>) {\n    if (!req.headers.has('Content-Type')) {\n      const detectedType = req.detectContentTypeHeader();\n      if (detectedType !== null) {\n        req = req.clone({\n          headers: req.headers.set('Content-Type', detectedType),\n        });\n      }\n    }\n    return req;\n  }\n\n  private encryptPayload(req: HttpRequest<unknown>) {\n    if (req.headers.get(CRYPTO_HEADER_KEY) && req.body) {\n      let bodyStr = '';\n      // 只对json和字符串类型的payload加密\n      if (typeof req.body === 'string') {\n        bodyStr = req.body;\n      } else {\n        try {\n          bodyStr = JSON.stringify(req.body);\n        } catch {}\n      }\n\n      if (bodyStr) {\n        // 将 angular 自动识别的逻辑加到这里来，避免加密后被统一设成 text\n        req = this.factoryContentType(req);\n\n        const random = v4().replaceAll('-', '');\n        req = req.clone({\n          headers: req.headers.set(CRYPTO_RANDOM_HEADER_KEY, random),\n          body: encrypt(bodyStr, random),\n        });\n      }\n    }\n\n    return req;\n  }\n\n  private factoryReq(req: HttpRequest<unknown>) {\n    if (\n      !req.headers.get(CRYPTO_HEADER_KEY) &&\n      defaultEnable(req, this.extraUrlRegexps)\n    ) {\n      req = req.clone({\n        headers: req.headers.set(CRYPTO_HEADER_KEY, CRYPTO_TYPE.Enable),\n      });\n    }\n\n    req = this.encryptPayload(req);\n\n    return req;\n  }\n\n  /**\n   * 实现方案：\n   * 1. 请求和响应处理分开处理，在请求的header上加上加密标识，根据返回的响应header处理对应的加密策略，而不是使用请求时使用的策略。这样能规避服务端的主动加密策略（前端没有使用加密）\n   * 2. 如果解密失败，将不做任何处理，原样返回，因为理论上解密不应该失败，如果失败可能是不需要解密，最主要的是返回解密失败的信息比原样返回对业务来说更没意义\n   */\n  intercept(\n    req: HttpRequest<unknown>,\n    next: HttpHandler,\n  ): Observable<HttpEvent<unknown>> {\n    req = this.factoryReq(req);\n\n    // 当是 progress ，例如 watch 场景的变更，不能获取 responseHeader，所以需要先在其他状态及时记录 responseHeader\n    let responseHeader: HttpHeaders;\n\n    return next.handle(req).pipe(\n      tap((event: HttpResponse<unknown>) => {\n        responseHeader = event.headers || responseHeader;\n      }),\n      map(event => {\n        const random = responseHeader?.get(CRYPTO_RANDOM_HEADER_KEY);\n        // 如果不是正常的响应\n        if (!(event instanceof HttpResponse)) {\n          if ((event as HttpDownloadProgressEvent).type === 3 && random) {\n            const progressEvent = event as HttpDownloadProgressEvent;\n            try {\n              progressEvent.partialText = decrypt(\n                random,\n                progressEvent.partialText,\n              );\n            } catch {}\n            return progressEvent;\n          }\n          return event;\n        }\n\n        // 如果是正常的响应\n        if (!random || !event.body) {\n          return event;\n        }\n\n        try {\n          return event.clone({\n            body: decrypt(random, event.body as string),\n          });\n        } catch {}\n        return event;\n      }),\n      catchError((err: HttpErrorResponse) => {\n        // 加密后返回的是字符串，所以如果请求的是json则一定是error的（如果 responseType 是 json，则无论响应的 content-type 是不是 json 都按照json解析）\n        const random = err?.headers?.get(CRYPTO_RANDOM_HEADER_KEY);\n        if (\n          random &&\n          req.responseType === 'json' &&\n          typeof err.error.text === 'string'\n        ) {\n          try {\n            // 如果存在加密标识且请求的是json，则这个错误基本上就是因为解析json导致的，所以尝试解密后进行json解析\n            const json = JSON.parse(decrypt(random, err.error.text));\n            // 如果解析成功则其就应该是一个正常的返回，所以生成一个正常的 HttpResponse\n            return of(\n              new HttpResponse({\n                body: json,\n                status: err.status,\n                headers: err.headers,\n                statusText: err.statusText,\n                url: err.url,\n              }),\n            );\n          } catch {\n            return throwError(() => err);\n          }\n        }\n        return throwError(() => err);\n      }),\n    );\n  }\n}\n\nfunction decrypt(random: string, content: string) {\n  // 先用 hex 把 content 解密\n  const contentHex = encHex.parse(content.replaceAll('\\n', ''));\n  // 随机数经过HMAC-sha256后取前端16字节，HMAC密钥为字符串“alauda”\n  const key = encHex.parse(\n    hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32),\n  );\n\n  return aes\n    .decrypt(encBase64.stringify(contentHex), key, {\n      iv: key,\n      mode: modeCtr,\n      padding: noPadding,\n    })\n    .toString(encUtf8);\n}\n\nfunction encrypt(content: string, random: string) {\n  const key = encHex.parse(\n    hmacSha256(random, CRYPTO_KEY).toString().slice(0, 32),\n  );\n\n  return aes\n    .encrypt(content, key, {\n      iv: key,\n      mode: modeCtr,\n      padding: noPadding,\n    })\n    .toString(formatHex);\n}\n"]}