http-wokou/pkg/include.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 (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"path"
)

type HttpServerConfig struct {
	HttpPort             int    `json:"http_port"`
	HttpsPort            int    `json:"https_port"`
	AllowedDomain        string `json:"allowed_domain"`
	FullDomain           string // The domain name with the protocol before it
	AltAllowedDomain     string `json:"alt_allowed_domain"` // alternate domain that resources are sourced from
	FullAltAllowedDomain string // the alt domain with the protocol
	Proto                string `json:"proto"` // http/https
	UserAgent            string `json:"user_agent"`
	UseSsl               bool   `json:"use_ssl"`
	ProxyAddr            string `json:"proxy_addr"`
	RouteMapDir          string `json:"routemap_dir"`
	PageModPath          string `json:"page_mod_path"`
	FullProxyDomain      string // the domain name of the proxied site with the protocol
	CookieJar            []*http.Cookie
	PhpSession           *http.Cookie
	SsoToken             *http.Cookie
}

type Cookie struct {
	Name       string `json:"name"`
	Value      string `json:"value"`
	MaxAge     int    `json:"max_age"`
	Path       string `json:"path"`
	Domain     string `json:"domain"`
	Secure     bool   `json:"secure"`
	IncludeSub bool   `json:"include_sub"`
}

type RouteMapping struct {
	DomainName string   `json:"domain_name"`
	UriPaths   []string `json:"uri_paths"`
	RouteSet   map[string]struct{}
}

/*
Reads the server configuration file, along with the cookie file so that the correlated account can be
accessed through the proxy

	:param loc: the location of the config file
*/
func ReadConfig(loc string) (*HttpServerConfig, error) {

	f, err := os.ReadFile(loc)
	if err != nil {
		return nil, err
	}
	var cfg HttpServerConfig
	err = json.Unmarshal(f, &cfg)
	if err != nil {
		return nil, err
	}
	cf, err := os.ReadFile("./cookies.json")
	if err != nil {
		return nil, err
	}
	cfg.FullDomain = fmt.Sprintf("%s://%s", cfg.Proto, cfg.AllowedDomain)
	cfg.FullProxyDomain = fmt.Sprintf("%s://%s", cfg.Proto, cfg.ProxyAddr)
	cfg.FullAltAllowedDomain = fmt.Sprintf("%s://%s", cfg.Proto, cfg.AltAllowedDomain)
	var cookies []Cookie
	err = json.Unmarshal(cf, &cookies)
	if err != nil {
		return nil, err
	}
	for idx := range cookies {
		httpCookie := &http.Cookie{
			Domain: cookies[idx].Domain,
			MaxAge: cookies[idx].MaxAge,
			Name:   cookies[idx].Name,
			Value:  cookies[idx].Value,
			Path:   cookies[idx].Path,
			Secure: cookies[idx].Secure,
		}
		cfg.CookieJar = append(cfg.CookieJar, httpCookie)
		if httpCookie.Name == "PHPSESSID" {
			cfg.PhpSession = httpCookie
		}
		if httpCookie.Name == "sso_token" {
			cfg.SsoToken = httpCookie
		}

	}

	fmt.Printf("%+v\n", cfg)
	return &cfg, err

}

func ReadRouteMap(loc string) *RouteMapping {
	f, err := os.ReadFile(loc)
	if err != nil {
		log.Fatal(err)
	}
	var mapfile RouteMapping
	err = json.Unmarshal(f, &mapfile)
	if err != nil {
		log.Fatal(err)
	}
	rmap := map[string]struct{}{}
	for idx := range mapfile.UriPaths {
		rmap[mapfile.UriPaths[idx]] = struct{}{}
	}
	mapfile.RouteSet = rmap

	return &mapfile

}

func PopulateRouteMaps(dir string) map[string]*RouteMapping {

	routeMaps := map[string]*RouteMapping{}
	fnames, err := ioutil.ReadDir(dir)
	if err != nil {
		log.Fatal("Failed to read the routemap directory: ", err)
	}
	for _, f := range fnames {
		mapping := ReadRouteMap(path.Join(dir, f.Name()))
		routeMaps[f.Name()] = mapping

	}
	return routeMaps
}