http-wokou/pkg/pagemod.go

/*
		GNU GENERAL PUBLIC LICENSE
                 Version 3, 29 June 2007

 Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
 Everyone is permitted to copy and distribute verbatim copies
 of this license document, but changing it is not allowed.

 http-wokou, An HTTP Proxying framework for bypassing DNS Security
 Copyright (C) 2024 Russell Hrubesky, ChiralWorks Software LLC

 This program is free software: you can redistribute it and/or modify
 it under the terms of the GNU General Public License as published by
 the Free Software Foundation, either version 3 of the License, or
 (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program.  If not, see <https://www.gnu.org/licenses/>.

*/

package httpserver

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"log"
	"os"
	"regexp"
)

type PageMod struct {
	Target string `json:"target"`
	Search string `json:"search"`
	Sub    string `json:"sub"`
}

/*
operate on a PageMod pointer to set the 'sub' field

	:param content: the content to set as the 'sub' field
*/
func (p *PageMod) SetFieldSub(content string) {
	p.Sub = content
}

/*
operate on a PageMod pointer and set the 'target' field

	:param content: the content to set as the 'target' field
*/
func (p *PageMod) SetFieldTarget(content string) {
	p.Target = content
}

type AllPageMods struct {
	Content []*PageMod          `json:"modifications"`
	Bypass  map[string]struct{} `json:"bypass"`
}

/*
Replace all of the upstreamDomains in the target data byte array with the proxyDomain

	    :param data: the page content to modify
		:param upstreamDomains: a list of strings containing the target domains to replace
		:param proxyDomain: the hostname of your proxy
*/
func DomainRewrite(data []byte, upstreamDomains []string, proxyDomain string) []byte { // TODO: replace this with a domain name detected regex

	for i := range upstreamDomains {
		data = bytes.ReplaceAll(data, []byte(upstreamDomains[i]), []byte(proxyDomain))
	}
	return data

}

/*
Load page modifications from the config/pagemod directory

	:param loc: the path to the pagemods directory
*/
func LoadPageMods(loc string) *AllPageMods {
	b, err := os.ReadFile(loc)
	if err != nil {
		log.Fatal("Couldnt load the page modification config from: ", loc, ". Error: ", err)
	}
	var pgMod AllPageMods
	err = json.Unmarshal(b, &pgMod)
	if err != nil {
		log.Fatal("There was an error loading the configuration: ", err)
	}
	for idx := range pgMod.Content {
		_, err = os.Stat(pgMod.Content[idx].Sub)
		if err != nil {
			if os.IsNotExist(err) {
				continue
			}

		}
		b, err = os.ReadFile(pgMod.Content[idx].Sub)
		if err != nil {
			log.Fatal("Could not read the target file: ", pgMod.Content[idx].Sub, " error: ", err)
		}
		pgMod.Content[idx].SetFieldTarget(string(b))
	}
	for idx := range pgMod.Content {
		_, err = os.Stat(pgMod.Content[idx].Target)
		if err != nil {
			if os.IsNotExist(err) {
				continue
			}
		}
		b, err = os.ReadFile(pgMod.Content[idx].Target)
		if err != nil {
			log.Fatal("Could not read the target file: ", pgMod.Content[idx].Target, " error: ", err)
		}
		pgMod.Content[idx].SetFieldSub(string(b))
		fmt.Print(string(b))
	}

	return &pgMod
}

func replaceDomains(data string, targetdomain string) string {
	reg := regexp.MustCompile(`^(?=.{1,253}\.?$)(?:(?!-|[^.]+_)[A-Za-z0-9-_]{1,63}(?<!-)(?:\.|$)){2,}$`)

	return reg.ReplaceAllString(string(data), targetdomain)

}

/*
Rewrite all occurences of these values into the response body
*/
func (c *Controller) pageMod(data []byte) []byte {
	data = DomainRewrite(data, c.Config.KnownHosts, c.Config.ProxyAddr)
	for idx := range c.PageMods.Content {
		if c.PageMods.Content[idx].Target == "content" {
			data = bytes.ReplaceAll(data, []byte(c.PageMods.Content[idx].Search), []byte(c.PageMods.Content[idx].Sub))
		}
	}
	return data
}

/*
perform any request body rewrites as per described in the pagemod config

	:param data: a byte array to modify
*/
func (c *Controller) requestBodyRewrites(data io.Reader) io.Reader {
	b, err := io.ReadAll(data)
	if err != nil {
		log.Fatal("couldnt read POST body data: ", err)
	}

	b = DomainRewrite(b, c.Config.KnownHosts, c.Config.ProxyAddr)

	for idx := range c.PageMods.Content {
		if c.PageMods.Content[idx].Target == "body" {
			b = bytes.ReplaceAll(b, []byte(c.PageMods.Content[idx].Search), []byte(c.PageMods.Content[idx].Sub))
		}
	}
	return bytes.NewReader(b)
}