libresilient/plugins/dnslink-fetch/index.js

/* ========================================================================= *\
|* === HTTP(S) fetch() from alternative endpoints                        === *|
\* ========================================================================= */

/**
 * this plugin does not implement any push method
 * 
 * NOTICE: this plugin uses Promise.any()
 *         https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/any
 *         the polyfill is implemented in LibResilient's service-worker.js
 */

// no polluting of the global namespace please
(function(LRPC){
    // this never changes
    const pluginName = "dnslink-fetch"
    LRPC.set(pluginName, (LR, init={})=>{
        
        /*
         * plugin config settings
         */
        
        // sane defaults
        let defaultConfig = {
            // how many simultaneous connections to different endpoints do we want
            // 
            // more concurrency means higher chance of a request succeeding
            // but uses more bandwidth and other resources;
            // 
            // 3 seems to be a reasonable default
            concurrency: 3,
            
            // DNS-over-HTTPS JSON API provider
            // 
            // by default using Hostux DoH provider, info here:
            // - https://dns.hostux.net/en/
            // 
            // other known DoH JSON API providers:
            // - 'https://cloudflare-dns.com/dns-query'
            // - 'https://mozilla.cloudflare-dns.com/dns-query'
            // - 'https://dns.google/resolve'
            dohProvider: 'https://dns.hostux.net/dns-query',
            
            // should the EDNS Client Subnet be masked from authoritative DNS servers for privacy?
            // - https://en.wikipedia.org/wiki/EDNS_Client_Subnet
            // - https://developers.google.com/speed/public-dns/docs/doh/json#supported_parameters
            ecsMasked: true
        }

        // merge the defaults with settings from the init var
        let config = {...defaultConfig, ...init}
        
        // reality check: dohProvider must be a string
        if (typeof(config.dohProvider) !== "string" || (config.dohProvider == '')) {
            let err = new Error("dohProvider not confgured")
            console.error(err)
            throw err
        }

        /**
         * retrieving the alternative endpoints list from dnslink
         * 
         * returns an array of strings, each being a valid endpoint, in the form of
         * scheme://example.org[/optional/path]
         */
        let resolveEndpoints = async (domain) => {
            
            // pretty self-explanatory:
            // DoH provider, _dnslink label in the domain, TXT type, pretty please
            var query = `${config.dohProvider}?name=_dnslink.${domain}&type=TXT`
            
            // do we want to mask the EDNS Client Subnet?
            // 
            // this protects user privacy somewhat by telling the DoH provider not to disclose
            // the subnet from which the DNS request came to authoritiative nameservers 
            if (config.ecsMasked) {
                query += '&edns_client_subnet=0.0.0.0/0'
            }
            
            // make the query, get the response
            var response = await fetch(
                                    query, {
                                        headers: {
                                            'accept': 'application/json',
                                        }
                                    })
                                .then(r=>r.json())
                                
            // we need an object here
            if (typeof response !== 'object') {
                throw new Error('Response is not a valid JSON')
            }
            
            // only Status == 0 is acceptable
            // https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml#dns-parameters-6
            if (!('Status' in response) || response.Status != 0) {
                throw new Error(`DNS request failure, status code: ${response.Status}`)
            }
            
            // we also do need the Answer section please
            if (!('Answer' in response) || (typeof response.Answer !== 'object') || (!Array.isArray(response.Answer))) {
                throw new Error(`DNS response did not contain a valid Answer section`)
            }
            
            // only get TXT records, and extract the data from them
            response = response
                        .Answer
                        .filter(r => r.type == 16)
                        .map(r => r.data);
            
            // did we get anything of value? anything at all?
            if (response.length < 1) {
                throw new Error(`Answer section of the DNS response did not contain any TXT records`)
            }
            
            // filter by 'dnslink="/https?/', morph into scheme://...
            // we can't rely on the data not to be wrapped in quotation marks, so we need to correct for that too
            let re = /^"?dnslink=\/(https?)\/([^"]+)"?$/
            response = response
                        .filter(r => re.test(r))
                        .map(r => r.replace(re, "$1:\/\/$2"));
                        
            // do we have anything to work with?
            if (response.length < 1) {
                throw new Error(`No TXT record contained http or https endpoint definition`)
            }
            
            // in case we need some debugging
            LR.log(pluginName, '+-- alternative endpoints from DNSLink:\n    - ', response.join('\n    - '))
            
            // this should be what we're looking for - an array of URLs
            return response
        }
        
        /**
         * getting content using regular HTTP(S) fetch()
         */
        let fetchContentFromAlternativeEndpoints = async (url, init={}) => {
            
            // remove the https://original.domain/ bit to get the relative path
            // TODO: this assumes that URLs we handle are always relative to the root
            // TODO: of the original domain, this needs to be documented
            var urlData = url.replace(/https?:\/\//, '').split('/') 
            var domain = urlData.shift()
            var path = urlData.join('/')
            LR.log(pluginName, '+-- fetching:\n',
                               `    - domain: ${domain}\n`,
                               `    -   path: ${path}\n`
            )
            
            // we really want to make fetch happen, Regina!
            // TODO: this change should *probably* be handled on the Service Worker level
            init.cache = 'reload'
            
            // we don't want to modify the original endpoints array
            var sourceEndpoints = await resolveEndpoints(domain)
            
            // if we have fewer than the configured concurrency or just as many, use all of them
            if (sourceEndpoints.length <= config.concurrency) {
                var useEndpoints = sourceEndpoints
                
            // otherwise get `config.concurrency` endpoints at random
            } else {
                var useEndpoints = new Array()
                while (useEndpoints.length < config.concurrency) {
                    useEndpoints.push(
                        sourceEndpoints
                            .splice(Math.floor(Math.random() * sourceEndpoints.length), 1)[0]
                    )
                }
            }
            
            // add the rest of the path to each endpoint
            useEndpoints.forEach((endpoint, index) => {
                useEndpoints[index] = endpoint + '/' + path;
            });
            
            // debug log
            LR.log(pluginName, `+-- fetching from alternative endpoints:\n    - ${useEndpoints.join('\n    - ')}`)
            
            return Promise.any(
                useEndpoints.map(
                    u=>fetch(u, init)
                ))
                .then((response) => {
                    // 4xx? 5xx? that's a paddlin'
                    if (response.status >= 400) {
                        // throw an Error to fall back to other plugins:
                        throw new Error('HTTP Error: ' + response.status + ' ' + response.statusText);
                    }
                    // all good, it seems
                    LR.log(pluginName, "fetched:", response.url);
                    
                    // we need to create a new Response object
                    // with all the headers added explicitly,
                    // since response.headers is immutable
                    var responseInit = {
                        status:     response.status,
                        statusText: response.statusText,
                        headers: {},
                        url: url
                    };
                    response.headers.forEach(function(val, header){
                        responseInit.headers[header] = val;
                    });
                    
                    // add the X-LibResilient-* headers to the mix
                    responseInit.headers['X-LibResilient-Method'] = pluginName
                    
                    // we will not have it most of the time, due to CORS rules:
                    // https://developer.mozilla.org/en-US/docs/Glossary/CORS-safelisted_response_header
                    responseInit.headers['X-LibResilient-ETag'] = response.headers.get('ETag')
                    if (responseInit.headers['X-LibResilient-ETag'] === null) {
                        // far from perfect, but what are we going to do, eh?
                        responseInit.headers['X-LibResilient-ETag'] = response.headers.get('last-modified')
                    }
                    
                    // return the new response, using the Blob from the original one
                    return response
                            .blob()
                            .then((blob) => {
                                return new Response(
                                    blob,
                                    responseInit
                                )
                            })
                })
        }

        // return the plugin data structure
        return {
            name: pluginName,
            description: 'HTTP(S) fetch() using alternative endpoints retrieved via DNSLink',
            version: 'COMMIT_UNKNOWN',
            fetch: fetchContentFromAlternativeEndpoints
        }
    
    })
// done with not polluting the global namespace
})(LibResilientPluginConstructors)