1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
|
/*
* SPDX-FileCopyrightText: syuilo and misskey-project
* SPDX-License-Identifier: AGPL-3.0-only
*/
import { URL } from 'node:url';
import { Injectable } from '@nestjs/common';
import { XMLParser } from 'fast-xml-parser';
import { HttpRequestService } from '@/core/HttpRequestService.js';
import { bindThis } from '@/decorators.js';
import type Logger from '@/logger.js';
import { RemoteLoggerService } from './RemoteLoggerService.js';
export type ILink = {
href: string;
rel?: string;
};
export type IWebFinger = {
links: ILink[];
subject: string;
};
const urlRegex = /^https?:\/\//;
const mRegex = /^([^@]+)@(.*)/;
// we have the colons here, because URL.protocol does as well, so it's
// more uniform in the places we use both
const defaultProtocol = process.env.MISSKEY_WEBFINGER_USE_HTTP?.toLowerCase() === 'true' ? 'http:' : 'https:';
@Injectable()
export class WebfingerService {
private logger: Logger;
constructor(
private httpRequestService: HttpRequestService,
private remoteLoggerService: RemoteLoggerService,
) {
this.logger = this.remoteLoggerService.logger.createSubLogger('webfinger');
}
@bindThis
public async webfinger(query: string): Promise<IWebFinger> {
const hostMetaUrl = this.queryToHostMetaUrl(query);
const template = await this.fetchWebFingerTemplateFromHostMeta(hostMetaUrl) ?? this.queryToWebFingerTemplate(query);
const url = this.genUrl(query, template);
return await this.httpRequestService.getJson<IWebFinger>(url, 'application/jrd+json, application/json');
}
@bindThis
private genUrl(query: string, template: string): string {
if (template.indexOf('{uri}') < 0) throw new Error(`Invalid webFingerUrl: ${template}`);
if (query.match(urlRegex)) {
return template.replace('{uri}', encodeURIComponent(query));
}
const m = query.match(mRegex);
if (m) {
return template.replace('{uri}', encodeURIComponent(`acct:${query}`));
}
throw new Error(`Invalid query (${query})`);
}
@bindThis
private queryToWebFingerTemplate(query: string): string {
if (query.match(urlRegex)) {
const u = new URL(query);
return `${u.protocol}//${u.hostname}/.well-known/webfinger?resource={uri}`;
}
const m = query.match(mRegex);
if (m) {
const hostname = m[2];
return `${defaultProtocol}//${hostname}/.well-known/webfinger?resource={uri}`;
}
throw new Error(`Invalid query (${query})`);
}
@bindThis
private queryToHostMetaUrl(query: string): string {
if (query.match(urlRegex)) {
const u = new URL(query);
return `${u.protocol}//${u.hostname}/.well-known/host-meta`;
}
const m = query.match(mRegex);
if (m) {
const hostname = m[2];
return `${defaultProtocol}//${hostname}/.well-known/host-meta`;
}
throw new Error(`Invalid query (${query})`);
}
@bindThis
private async fetchWebFingerTemplateFromHostMeta(url: string): Promise<string | null> {
try {
const res = await this.httpRequestService.getHtml(url, 'application/xrd+xml');
const options = {
ignoreAttributes: false,
isArray: (_name: string, jpath: string) => jpath === 'XRD.Link',
};
const parser = new XMLParser(options);
const hostMeta = parser.parse(res);
const template = (hostMeta['XRD']['Link'] as Array<any>).filter(p => p['@_rel'] === 'lrdd')[0]['@_template'];
return template.indexOf('{uri}') < 0 ? null : template;
} catch (err) {
this.logger.error(`error while request host-meta for ${url}: ${err}`);
return null;
}
}
}
|
