diff --git a/server.ts b/server.ts index d92310746e9..a2f2d75aa7a 100644 --- a/server.ts +++ b/server.ts @@ -55,6 +55,7 @@ import { APP_CONFIG, AppConfig } from './src/config/app-config.interface'; import { extendEnvironmentWithAppConfig } from './src/config/config.util'; import { logStartupMessage } from './startup-message'; import { TOKENITEM } from './src/app/core/auth/models/auth-token-info.model'; +import { getSsrCacheKey } from './src/app/shared/ssr-cache-key.util'; import { SsrExcludePatterns } from './src/config/universal-config.interface'; @@ -383,14 +384,14 @@ function anonymousCacheEnabled(): boolean { /** * Check if the currently requested page is in our server-side, in-memory cache. - * Caching is ONLY done for SSR requests. Pages are cached base on their path (e.g. /home or /search?query=test) + * Caching is ONLY done for SSR requests. Pages are cached by path, origin and language (see getSsrCacheKey) */ function cacheCheck(req, res, next) { // Cached copy of page (if found) let cachedCopy; - // If the bot cache is enabled and this request looks like a bot, check the bot cache for a cached page. - if (botCacheEnabled() && isbot(req.get('user-agent'))) { + // If the bot cache is enabled and this request looks like an anonymous bot, check the bot cache for a cached page. + if (botCacheEnabled() && isbot(req.get('user-agent')) && !isUserAuthenticated(req)) { cachedCopy = checkCacheForRequest('bot', botCache, req, res); } else if (anonymousCacheEnabled() && !isUserAuthenticated(req)) { cachedCopy = checkCacheForRequest('anonymous', anonymousCache, req, res); @@ -433,7 +434,7 @@ function cacheCheck(req, res, next) { */ function checkCacheForRequest(cacheName: string, cache: LRU, req, res): any { // Get the cache key for this request - const key = getCacheKey(req); + const key = getSsrCacheKey(req); // Check if this page is in our cache let cachedCopy = cache.get(key); @@ -457,18 +458,6 @@ function checkCacheForRequest(cacheName: string, cache: LRU, req, r return cachedCopy; } -/** - * Create a cache key from the current request. - * The cache key is the URL path (NOTE: this key will also include any querystring params). - * E.g. "/home" or "/search?query=test" - * @param req current request - * @returns cache key to use for this page - */ -function getCacheKey(req): string { - // NOTE: this will return the URL path *without* any baseUrl - return req.url; -} - /** * Save page to server side cache(s), if enabled. If caching is not enabled or a user is authenticated, this is a noop * If multiple caches are enabled, the page will be saved to any caches where it does not yet exist (or is expired). @@ -481,9 +470,9 @@ function saveToCache(req, page: any) { // NOTE: It's not safe to save page data to the cache when a user is authenticated. In that situation, // the page may include sensitive or user-specific materials. As the cache is shared across all users, it can only contain public info. if (!isUserAuthenticated(req)) { - const key = getCacheKey(req); + const key = getSsrCacheKey(req); // Avoid caching "/reload/[random]" paths (these are hard refreshes after logout) - if (key.startsWith('/reload')) { return; } + if (req.url.startsWith('/reload')) { return; } // Avoid caching not successful responses (status code different from 2XX status) if (hasNotSucceeded(req.res.statusCode)) { return; } diff --git a/src/app/shared/html-content.service.spec.ts b/src/app/shared/html-content.service.spec.ts new file mode 100644 index 00000000000..030f8780ea1 --- /dev/null +++ b/src/app/shared/html-content.service.spec.ts @@ -0,0 +1,42 @@ +import { TestBed } from '@angular/core/testing'; +import { HttpClientTestingModule, HttpTestingController } from '@angular/common/http/testing'; + +import { HtmlContentService } from './html-content.service'; +import { LocaleService } from '../core/locale/locale.service'; + +class LocaleServiceStub { + languageCode = 'en'; + + getCurrentLanguageCode(): string { + return this.languageCode; + } +} + +describe('HtmlContentService', () => { + let service: HtmlContentService; + let httpMock: HttpTestingController; + + beforeEach(() => { + TestBed.configureTestingModule({ + imports: [HttpClientTestingModule], + providers: [ + HtmlContentService, + { provide: LocaleService, useClass: LocaleServiceStub }, + ], + }); + + service = TestBed.inject(HtmlContentService); + httpMock = TestBed.inject(HttpTestingController); + }); + + afterEach(() => { + httpMock.verify(); + }); + + it('should not request a file name that leaves static-files once decoded', async () => { + const promise = service.getHmtlContentByPathAndLocale('..%2Findex'); + + httpMock.expectNone(() => true); + expect(await promise).toBeUndefined(); + }); +}); diff --git a/src/app/shared/html-content.service.ts b/src/app/shared/html-content.service.ts index 2b31c7cfb81..3ff6fc3a57a 100644 --- a/src/app/shared/html-content.service.ts +++ b/src/app/shared/html-content.service.ts @@ -24,10 +24,26 @@ export class HtmlContentService { catchError(() => observableOf(''))); } + /** + * Whether a file name taken from the URL is still one file name once the server decodes it, + * so it cannot address a file outside `static-files` (e.g. `..%2Findex`). A query part is ignored. + */ + private isPlainFileName(fileName: string): boolean { + try { + return !/[/\\]/.test(decodeURIComponent(fileName.split('?')[0])); + } catch { + // Missing name or malformed percent-encoding: nothing to load. + return false; + } + } + /** * Get the html file content as a string by the file name and the current locale. */ async getHmtlContentByPathAndLocale(fileName: string) { + if (!this.isPlainFileName(fileName)) { + return undefined; + } let url = ''; // Get current language let language = this.localeService.getCurrentLanguageCode(); diff --git a/src/app/shared/ssr-cache-key.util.spec.ts b/src/app/shared/ssr-cache-key.util.spec.ts new file mode 100644 index 00000000000..7c8827fa197 --- /dev/null +++ b/src/app/shared/ssr-cache-key.util.spec.ts @@ -0,0 +1,21 @@ +import { Request } from 'express'; + +import { getSsrCacheKey } from './ssr-cache-key.util'; +import { LANG_COOKIE } from '../core/locale/locale.service'; + +describe('getSsrCacheKey', () => { + function request(protocol: string, host: string, cookies: Record = {}): Request { + return { url: '/static/about', protocol, get: () => host, cookies } as unknown as Request; + } + + it('should separate renders for different language cookies', () => { + expect(getSsrCacheKey(request('https', 'repo.example', { [LANG_COOKIE]: 'cs' }))) + .not.toEqual(getSsrCacheKey(request('https', 'repo.example', { [LANG_COOKIE]: 'en' }))); + }); + + it('should separate renders for different request origins', () => { + const key = getSsrCacheKey(request('https', 'repo.example')); + expect(getSsrCacheKey(request('https', 'attacker.example'))).not.toEqual(key); + expect(getSsrCacheKey(request('http', 'repo.example'))).not.toEqual(key); + }); +}); diff --git a/src/app/shared/ssr-cache-key.util.ts b/src/app/shared/ssr-cache-key.util.ts new file mode 100644 index 00000000000..4f05e1479c5 --- /dev/null +++ b/src/app/shared/ssr-cache-key.util.ts @@ -0,0 +1,12 @@ +import { Request } from 'express'; +import { LANG_COOKIE } from '../core/locale/locale.service'; + +/** + * Key of a server-side rendered page in the SSR page caches (see server.ts). + * Besides path and query, an anonymous render depends on the request origin (protocol and Host header, + * e.g. in `citation_pdf_url`) and on the language cookie, so they are part of the key. + * @param req current request + */ +export function getSsrCacheKey(req: Request): string { + return JSON.stringify([req.protocol, req.get('host'), req.cookies?.[LANG_COOKIE], req.url]); +}