curlinate 0.0.1__tar.gz

curlinate-0.0.1/PKG-INFO

@@ -0,0 +1,14 @@
+Metadata-Version: 2.1
+Name: curlinate
+Version: 0.0.1
+Summary: Command-line utility and Python library to simplify TLS fingerprint forgery
+Home-page: https://github.com/radian-software/curlinate
+Author: Radian LLC
+Maintainer: Radian LLC
+Maintainer-email: contact+curlinate@radian.codes
+License: MIT
+Download-URL: https://pypi.python.org/pypi/curlinate
+Project-URL: Bug Tracker, https://github.com/radian-software/curlinate/issues
+Project-URL: Documentation, https://github.com/radian-software/curlinate
+Project-URL: Source Code, https://github.com/radian-software/curlinate
+Requires-Python: >=3.8,<4.0

curlinate-0.0.1/curlinate.go

@@ -0,0 +1,253 @@
+package main
+
+import (
+	"bufio"
+	"bytes"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+
+	"github.com/alecthomas/kong"
+	"github.com/refraction-networking/utls"
+	"golang.org/x/net/http2"
+)
+
+type argsType struct {
+	URL         string   `arg:"" help:"Fully qualified URL to contact" required:"" json:"url"`
+	Method      string   `short:"X" name:"method" help:"HTTP method to use" default:"GET" json:"method"`
+	Headers     []string `sep:"none" short:"H" name:"header" help:"Additional http headers in format 'Header: Value'" json:"headers"`
+	Body        string   `name:"body" help:"Request body, must be UTF-8 due to limitation in argument parser" json:"body"`
+	BodyBase64  bool     `name:"body-base64" help:"Assume request body is base64 encoded, so null bytes can be used" json:"body_base64"`
+	ClientHello string   `name:"clienthello" help:"Base64 encoded raw ClientHello message to emulate" env:"CLIENTHELLO" json:"clienthello"`
+	ConnId      string   `kong:"-" json:"conn_id"`
+	multiple    bool
+	useJson     bool
+}
+
+type sessionResp struct {
+	Status  int      `json:"status"`
+	Headers []string `json:"headers"`
+	Body    []byte   `json:"body"`
+}
+
+func getMapKeys(m map[string]string) []string {
+	keys := []string{}
+	for key := range m {
+		keys = append(keys, key)
+	}
+	return keys
+}
+
+var savedConns = map[string]*tls.UConn{}
+
+func mainE(args *argsType) error {
+	// First check if we are in session mode, if so, read new args
+	// from stdin and recurse.
+	if args.multiple {
+		fmt.Fprintln(os.Stderr, "ignoring args and reading commands from stdin")
+		scanner := bufio.NewScanner(os.Stdin)
+		for scanner.Scan() {
+			subargs := argsType{}
+			err := json.Unmarshal(scanner.Bytes(), &subargs)
+			if err != nil {
+				return err
+			}
+			subargs.useJson = true
+			err = mainE(&subargs)
+			if err != nil {
+				return err
+			}
+		}
+		return nil
+	}
+	// Need to validate args again because it is possible to
+	// bypass the cmdline validation in session mode
+	if args.URL == "" {
+		return errors.New("url is required")
+	}
+	// Kong doesn't seem to want to read bytes as base64 like
+	// json, so we have to do it manually
+	if args.ClientHello == "" {
+		args.ClientHello = os.Getenv("CLIENTHELLO")
+	}
+	clienthello := []byte{}
+	if args.ClientHello != "" {
+		encoder := base64.NewDecoder(base64.StdEncoding, bytes.NewReader([]byte(args.ClientHello)))
+		var err error
+		clienthello, err = io.ReadAll(encoder)
+		if err != nil {
+			return err
+		}
+	}
+	// Proceed to main logic
+	parsedURL, err := url.Parse(args.URL)
+	if err != nil {
+		return err
+	}
+	// Parse the headers into a map
+	parsedHeaders := http.Header{}
+	for _, header := range args.Headers {
+		splits := strings.SplitN(header, ": ", 2)
+		if len(splits) != 2 {
+			return fmt.Errorf("bad header format: %v", header)
+		}
+		key := splits[0]
+		value := splits[1]
+		parsedHeaders.Add(key, value)
+	}
+	if err != nil {
+		return err
+	}
+	// Parse the body into a byte array
+	parsedBody := []byte(args.Body)
+	if args.BodyBase64 {
+		encoder := base64.NewDecoder(base64.StdEncoding, bytes.NewReader(parsedBody))
+		parsedBody, err = io.ReadAll(encoder)
+		if err != nil {
+			return err
+		}
+	}
+	var tlsConn *tls.UConn = nil
+	if args.ConnId != "" {
+		tlsConn = savedConns[args.ConnId]
+	}
+	if tlsConn == nil {
+		var tlsId tls.ClientHelloID
+		var tlsSpec *tls.ClientHelloSpec
+		if len(clienthello) > 0 {
+			tlsId = tls.HelloCustom
+			tlsFingerprinter := &tls.Fingerprinter{
+				AllowBluntMimicry: true,
+			}
+			tlsSpec, err = tlsFingerprinter.FingerprintClientHello(clienthello)
+			if err != nil {
+				return err
+			}
+		} else {
+			tlsId = tls.HelloFirefox_56
+			tlsSpec = nil
+		}
+		if parsedURL.Scheme != "https" {
+			return fmt.Errorf("unsupported scheme %s, only https is allowed", parsedURL.Scheme)
+		}
+		host := parsedURL.Host
+		if !strings.Contains(host, ":") {
+			host += ":443"
+		}
+		tcpConn, err := net.Dial("tcp", host)
+		if err != nil {
+			return err
+		}
+		tlsConfig := tls.Config{ServerName: parsedURL.Hostname()}
+		tlsConn = tls.UClient(tcpConn, &tlsConfig, tlsId)
+		if tlsSpec != nil {
+			err = tlsConn.ApplyPreset(tlsSpec)
+			if err != nil {
+				return err
+			}
+		}
+		err = tlsConn.Handshake()
+		if err != nil {
+			return err
+		}
+		if args.ConnId == "" {
+			defer tlsConn.Close()
+		} else {
+			savedConns[args.ConnId] = tlsConn
+		}
+	}
+	req := &http.Request{
+		Method:        args.Method,
+		URL:           parsedURL,
+		Header:        parsedHeaders,
+		Body:          io.NopCloser(bytes.NewReader(parsedBody)),
+		ContentLength: int64(len(parsedBody)),
+	}
+	var resp *http.Response
+	alpn := tlsConn.HandshakeState.ServerHello.AlpnProtocol
+	switch alpn {
+	case "h2":
+		req.Proto = "HTTP/2.0"
+		req.ProtoMajor = 2
+		req.ProtoMinor = 0
+
+		tr := http2.Transport{}
+		clientConn, err := tr.NewClientConn(tlsConn)
+		if err != nil {
+			return err
+		}
+		resp, err = clientConn.RoundTrip(req)
+		if err != nil {
+			return err
+		}
+	case "http/1.1", "":
+		req.Proto = "HTTP/1.1"
+		req.ProtoMajor = 1
+		req.ProtoMinor = 1
+		err := req.Write(tlsConn)
+		if err != nil {
+			return err
+		}
+		resp, err = http.ReadResponse(bufio.NewReader(tlsConn), req)
+		if err != nil {
+			return err
+		}
+	default:
+		return fmt.Errorf("unexpected ALPN: %s", alpn)
+	}
+	if !args.useJson {
+		fmt.Fprintf(os.Stderr, "status %s\n", resp.Status)
+		for key, vals := range resp.Header {
+			for _, val := range vals {
+				fmt.Fprintf(os.Stderr, "header %s: %s\n", key, val)
+			}
+		}
+	}
+	respBody, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return err
+	}
+	defer resp.Body.Close()
+	if !args.useJson {
+		fmt.Fprintf(os.Stderr, "body %d bytes\n", len(respBody))
+		fmt.Printf("%s", respBody)
+	} else {
+		headers := []string{}
+		for key, vals := range resp.Header {
+			for _, val := range vals {
+				headers = append(headers, fmt.Sprintf("%s: %s", key, val))
+			}
+		}
+		msg, err := json.Marshal(sessionResp{
+			Status:  resp.StatusCode,
+			Headers: headers,
+			Body:    respBody,
+		})
+		if err != nil {
+			return err
+		}
+		fmt.Println(string(msg))
+	}
+	return nil
+}
+
+func main() {
+	args := argsType{}
+	if len(os.Args) == 2 && os.Args[1] == "multiple" {
+		args.multiple = true
+	} else {
+		kong.Parse(&args)
+	}
+	err := mainE(&args)
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "fatal: %s\n", err.Error())
+		os.Exit(1)
+	}
+}

curlinate-0.0.1/curlinate.py

@@ -0,0 +1,443 @@
+import base64
+from collections.abc import Mapping, MutableMapping
+from collections import OrderedDict
+from dataclasses import dataclass
+import gzip
+import io
+import json
+import re
+import subprocess
+from typing import Tuple
+import urllib.parse
+
+
+# Cribbed from requests
+class CaseInsensitiveDict(MutableMapping):
+    def __init__(self, data=None, **kwargs):
+        self._store = OrderedDict()
+        if data is None:
+            data = {}
+        self.update(data, **kwargs)
+
+    def __setitem__(self, key, value):
+        self._store[key.lower()] = (key, value)
+
+    def __getitem__(self, key):
+        return self._store[key.lower()][1]
+
+    def __delitem__(self, key):
+        del self._store[key.lower()]
+
+    def __iter__(self):
+        return (casedkey for casedkey, _ in self._store.values())
+
+    def __len__(self):
+        return len(self._store)
+
+    def lower_items(self):
+        return ((lowerkey, keyval[1]) for (lowerkey, keyval) in self._store.items())
+
+    def __eq__(self, other):
+        if isinstance(other, Mapping):
+            other = CaseInsensitiveDict(other)
+        else:
+            return NotImplemented
+        return dict(self.lower_items()) == dict(other.lower_items())
+
+    def copy(self):
+        return CaseInsensitiveDict(self._store.values())
+
+    def __repr__(self):
+        return str(dict(self.items()))
+
+
+class HTTPError(Exception):
+    def __init__(self, msg, response):
+        super().__init__(msg)
+        self.response = response
+
+
+@dataclass
+class Response:
+    status_code: int
+    headers: CaseInsensitiveDict
+    content: bytes
+
+    @property
+    def ok(self):
+        return not (400 < self.status_code < 600)
+
+    def raise_for_status(self):
+        if not self.ok:
+            raise HTTPError(f"{self.status_code} Server Error", response=self)
+
+    @property
+    def _content(self):
+        content = self.content
+        if self.headers.get("content-encoding") == "gzip":
+            with gzip.open(io.BytesIO(content)) as f:
+                content = f.read()
+        return content
+
+    @property
+    def text(self):
+        # Todo: decode using appropriate charset from content type
+        return self._content.decode()
+
+    def json(self):
+        return json.loads(self._content)
+
+
+def _fixup_request_args(
+    method: str,
+    url: str,
+    data: bytes | dict[str, str],
+    headers: dict[str, str],
+    cookies: dict[str, str],
+    params: dict[str, str],
+    clienthello: str,
+) -> Tuple[str, str, bytes, dict[str, str], dict[str, str], dict[str, str], str]:
+    if isinstance(data, dict):
+        data = urllib.parse.urlencode(data).encode()
+        if not CaseInsensitiveDict(headers).get("content-type"):
+            headers = {
+                **headers,
+                "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+            }
+    if cookies:
+        if CaseInsensitiveDict(headers).get("cookie"):
+            raise RuntimeError(
+                "can't use extra cookies with request that already has cookie header"
+            )
+        headers = {
+            **headers,
+            "Cookie": "; ".join(f"{key}={val}" for key, val in cookies.items()),
+        }
+    if params:
+        if "?" in url:
+            raise RuntimeError(
+                "can't use extra query params with url that already has query string"
+            )
+        url += "?" + urllib.parse.urlencode(params)
+    method = method.upper()
+    return method, url, data, headers, cookies, params, clienthello
+
+
+def request(
+    method,
+    url,
+    *,
+    data: (bytes | dict[str, str]) = b"",
+    headers: dict[str, str] = {},
+    cookies: dict[str, str] = {},
+    params: dict[str, str] = {},
+    clienthello: str = "",
+):
+    method, url, data, headers, cookies, params, clienthello = _fixup_request_args(
+        method, url, data, headers, cookies, params, clienthello
+    )
+    result = subprocess.run(
+        [
+            "curlinate",
+            "-X",
+            method.upper(),
+            url,
+            *[f"-H{key}: {value}" for key, value in headers.items()],
+            *(["--body", base64.b64encode(data), "--body-base64"] if data else []),
+            *(["--clienthello", clienthello] if clienthello else []),
+        ],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    stdout = result.stdout
+    stderr = result.stderr.decode()
+    if result.returncode != 0:
+        error = (
+            stderr.strip().splitlines()[-1].strip()
+            or f"exit status {result.returncode}"
+        )
+        raise RuntimeError(f"got error from curlinate subprocess: {error}")
+    status_code_match = re.search(r"(?m)^status ([0-9]+)", stderr)
+    try:
+        if not status_code_match:
+            raise ValueError
+        status_code = int(status_code_match.group(1))
+    except (AttributeError, ValueError) as _:
+        raise RuntimeError(
+            f"unable to parse output from curlinate subprocess: {repr(stderr)}"
+        ) from None
+    resp_headers = CaseInsensitiveDict()
+    for key, value in re.findall(r"(?m)^header ([^:]+): (.+)", stderr):
+        resp_headers[key] = value
+    return Response(status_code, resp_headers, stdout)
+
+
+def delete(
+    url,
+    *,
+    data: (bytes | dict[str, str]) = b"",
+    headers: dict[str, str] = {},
+    cookies: dict[str, str] = {},
+    params: dict[str, str] = {},
+    clienthello: str = "",
+):
+    return request(
+        "DELETE",
+        url,
+        data=data,
+        headers=headers,
+        cookies=cookies,
+        params=params,
+        clienthello=clienthello,
+    )
+
+
+def get(
+    url,
+    *,
+    headers: dict[str, str] = {},
+    cookies: dict[str, str] = {},
+    params: dict[str, str] = {},
+    clienthello: str = "",
+):
+    return request(
+        "GET",
+        url,
+        headers=headers,
+        cookies=cookies,
+        params=params,
+        clienthello=clienthello,
+    )
+
+
+def patch(
+    url,
+    *,
+    data: (bytes | dict[str, str]) = b"",
+    headers: dict[str, str] = {},
+    cookies: dict[str, str] = {},
+    params: dict[str, str] = {},
+    clienthello: str = "",
+):
+    return request(
+        "PATCH",
+        url,
+        data=data,
+        headers=headers,
+        cookies=cookies,
+        params=params,
+        clienthello=clienthello,
+    )
+
+
+def post(
+    url,
+    *,
+    data: (bytes | dict[str, str]) = b"",
+    headers: dict[str, str] = {},
+    cookies: dict[str, str] = {},
+    params: dict[str, str] = {},
+    clienthello: str = "",
+):
+    return request(
+        "POST",
+        url,
+        data=data,
+        headers=headers,
+        cookies=cookies,
+        params=params,
+        clienthello=clienthello,
+    )
+
+
+def put(
+    url,
+    *,
+    data: (bytes | dict[str, str]) = b"",
+    headers: dict[str, str] = {},
+    cookies: dict[str, str] = {},
+    params: dict[str, str] = {},
+    clienthello: str = "",
+):
+    return request(
+        "PUT",
+        url,
+        data=data,
+        headers=headers,
+        cookies=cookies,
+        params=params,
+        clienthello=clienthello,
+    )
+
+
+class Session:
+    def __init__(self, clienthello: str | None = None):
+        self.proc = subprocess.Popen(
+            ["curlinate", "multiple"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            bufsize=0,
+        )
+        self.clienthello = clienthello or ""
+
+    def __del__(self):
+        assert self.proc.stdin
+        self.proc.kill()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *_):
+        self.__del__()
+
+    def request(
+        self,
+        method,
+        url,
+        *,
+        data: (bytes | dict[str, str]) = b"",
+        headers: dict[str, str] = {},
+        cookies: dict[str, str] = {},
+        params: dict[str, str] = {},
+        clienthello: str = "",
+    ):
+        if not clienthello:
+            clienthello = self.clienthello
+        method, url, data, headers, cookies, params, clienthello = _fixup_request_args(
+            method, url, data, headers, cookies, params, clienthello
+        )
+        assert self.proc.stdin
+        assert self.proc.stdout
+        assert self.proc.stderr
+        self.proc.stdin.write(
+            json.dumps(
+                {
+                    "url": url,
+                    "method": method,
+                    "headers": [f"{key}: {value}" for key, value in headers.items()],
+                    **(
+                        {"body": base64.b64encode(data).decode(), "body_base64": True}
+                        if data
+                        else {}
+                    ),
+                    "clienthello": clienthello,
+                    "conn_id": "curlinate",
+                }
+            ).encode()
+            + b"\n"
+        )
+        line = self.proc.stdout.readline()
+        if not line:
+            try:
+                error = (
+                    self.proc.stderr.read().decode().strip().splitlines()[-1].strip()
+                    or "unknown error"
+                )
+            except Exception:
+                error = "unknown error"
+            raise RuntimeError(f"got error from curlinate subprocess: {error}")
+        resp = json.loads(line)
+        resp_headers = CaseInsensitiveDict()
+        for header in resp["headers"]:
+            key, value = header.split(": ", maxsplit=1)
+            resp_headers[key] = value
+        return Response(resp["status"], resp_headers, base64.b64decode(resp["body"]))
+
+    def delete(
+        self,
+        url,
+        *,
+        data: (bytes | dict[str, str]) = b"",
+        headers: dict[str, str] = {},
+        cookies: dict[str, str] = {},
+        params: dict[str, str] = {},
+        clienthello: str = "",
+    ):
+        return self.request(
+            "DELETE",
+            url,
+            data=data,
+            headers=headers,
+            cookies=cookies,
+            params=params,
+            clienthello=clienthello,
+        )
+
+    def get(
+        self,
+        url,
+        *,
+        headers: dict[str, str] = {},
+        cookies: dict[str, str] = {},
+        params: dict[str, str] = {},
+        clienthello: str = "",
+    ):
+        return self.request(
+            "GET",
+            url,
+            headers=headers,
+            cookies=cookies,
+            params=params,
+            clienthello=clienthello,
+        )
+
+    def patch(
+        self,
+        url,
+        *,
+        data: (bytes | dict[str, str]) = b"",
+        headers: dict[str, str] = {},
+        cookies: dict[str, str] = {},
+        params: dict[str, str] = {},
+        clienthello: str = "",
+    ):
+        return self.request(
+            "PATCH",
+            url,
+            data=data,
+            headers=headers,
+            cookies=cookies,
+            params=params,
+            clienthello=clienthello,
+        )
+
+    def post(
+        self,
+        url,
+        *,
+        data: (bytes | dict[str, str]) = b"",
+        headers: dict[str, str] = {},
+        cookies: dict[str, str] = {},
+        params: dict[str, str] = {},
+        clienthello: str = "",
+    ):
+        return self.request(
+            "POST",
+            url,
+            data=data,
+            headers=headers,
+            cookies=cookies,
+            params=params,
+            clienthello=clienthello,
+        )
+
+    def put(
+        self,
+        url,
+        *,
+        data: (bytes | dict[str, str]) = b"",
+        headers: dict[str, str] = {},
+        cookies: dict[str, str] = {},
+        params: dict[str, str] = {},
+        clienthello: str = "",
+    ):
+        return self.request(
+            "PUT",
+            url,
+            data=data,
+            headers=headers,
+            cookies=cookies,
+            params=params,
+            clienthello=clienthello,
+        )

curlinate-0.0.1/go.mod

@@ -0,0 +1,18 @@
+module github.com/radian-software/curlinate
+
+go 1.20
+
+require github.com/alecthomas/kong v0.7.1
+
+require (
+	github.com/andybalholm/brotli v1.0.5 // indirect
+	github.com/cloudflare/circl v1.3.3 // indirect
+	github.com/gaukas/godicttls v0.0.4 // indirect
+	github.com/klauspost/compress v1.16.7 // indirect
+	github.com/quic-go/quic-go v0.37.4 // indirect
+	github.com/refraction-networking/utls v1.5.2 // indirect
+	golang.org/x/crypto v0.12.0 // indirect
+	golang.org/x/net v0.14.0 // indirect
+	golang.org/x/sys v0.11.0 // indirect
+	golang.org/x/text v0.12.0 // indirect
+)

curlinate-0.0.1/go.sum

@@ -0,0 +1,25 @@
+github.com/alecthomas/assert/v2 v2.1.0 h1:tbredtNcQnoSd3QBhQWI7QZ3XHOVkw1Moklp2ojoH/0=
+github.com/alecthomas/kong v0.7.1 h1:azoTh0IOfwlAX3qN9sHWTxACE2oV8Bg2gAwBsMwDQY4=
+github.com/alecthomas/kong v0.7.1/go.mod h1:n1iCIO2xS46oE8ZfYCNDqdR0b0wZNrXAIAqro/2132U=
+github.com/alecthomas/repr v0.1.0 h1:ENn2e1+J3k09gyj2shc0dHr/yjaWSHRlrJ4DPMevDqE=
+github.com/andybalholm/brotli v1.0.5 h1:8uQZIdzKmjc/iuPu7O2ioW48L81FgatrcpfFmiq/cCs=
+github.com/andybalholm/brotli v1.0.5/go.mod h1:fO7iG3H7G2nSZ7m0zPUDn85XEX2GTukHGRSepvi9Eig=
+github.com/cloudflare/circl v1.3.3 h1:fE/Qz0QdIGqeWfnwq0RE0R7MI51s0M2E4Ga9kq5AEMs=
+github.com/cloudflare/circl v1.3.3/go.mod h1:5XYMA4rFBvNIrhs50XuiBJ15vF2pZn4nnUKZrLbUZFA=
+github.com/gaukas/godicttls v0.0.4 h1:NlRaXb3J6hAnTmWdsEKb9bcSBD6BvcIjdGdeb0zfXbk=
+github.com/gaukas/godicttls v0.0.4/go.mod h1:l6EenT4TLWgTdwslVb4sEMOCf7Bv0JAK67deKr9/NCI=
+github.com/hexops/gotextdiff v1.0.3 h1:gitA9+qJrrTCsiCl7+kh75nPqQt1cx4ZkudSTLoUqJM=
+github.com/klauspost/compress v1.16.7 h1:2mk3MPGNzKyxErAw8YaohYh69+pa4sIQSC0fPGCFR9I=
+github.com/klauspost/compress v1.16.7/go.mod h1:ntbaceVETuRiXiv4DpjP66DpAtAGkEQskQzEyD//IeE=
+github.com/quic-go/quic-go v0.37.4 h1:ke8B73yMCWGq9MfrCCAw0Uzdm7GaViC3i39dsIdDlH4=
+github.com/quic-go/quic-go v0.37.4/go.mod h1:YsbH1r4mSHPJcLF4k4zruUkLBqctEMBDR6VPvcYjIsU=
+github.com/refraction-networking/utls v1.5.2 h1:l6diiLbEoRqdQ+/osPDO0z0lTc8O8VZV+p82N+Hi+ws=
+github.com/refraction-networking/utls v1.5.2/go.mod h1:SPuDbBmgLGp8s+HLNc83FuavwZCFoMmExj+ltUHiHUw=
+golang.org/x/crypto v0.12.0 h1:tFM/ta59kqch6LlvYnPa0yx5a83cL2nHflFhYKvv9Yk=
+golang.org/x/crypto v0.12.0/go.mod h1:NF0Gs7EO5K4qLn+Ylc+fih8BSTeIjAP05siRnAh98yw=
+golang.org/x/net v0.14.0 h1:BONx9s002vGdD9umnlX1Po8vOZmrgH34qlHcD1MfK14=
+golang.org/x/net v0.14.0/go.mod h1:PpSgVXXLK0OxS0F31C1/tv6XNguvCrnXIDrFMspZIUI=
+golang.org/x/sys v0.11.0 h1:eG7RXZHdqOJ1i+0lgLgCpSXAp6M3LYlAo6osgSi0xOM=
+golang.org/x/sys v0.11.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/text v0.12.0 h1:k+n5B8goJNdU7hSvEtMUz3d1Q6D/XW4COJSJR6fN0mc=
+golang.org/x/text v0.12.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=

curlinate-0.0.1/pybuild/build.py

@@ -0,0 +1,152 @@
+# Yeah, I wrote my own fucking PEP517 build backend. Because after
+# spending too many goddamn hours figuring out how to coax setuptools
+# into installing binaries properly it turned out to be less work to
+# reimplement the entire fucking thing. https://xkcd.com/1987/ seems
+# to be as true as ever. And don't even get me started on trying to do
+# it with Poetry, that managed to be even worse.
+#
+# I will say the folks who wrote https://peps.python.org/pep-0517/ did
+# an amazing job though. That was the only sane document I read in this
+# entire many-hour journey. https://pypa-build.readthedocs.io/en/stable/
+# is great too, and https://peps.python.org/pep-0660/ is eminently reasonable.
+
+import base64
+import hashlib
+import os
+import pathlib
+import shlex
+import shutil
+import subprocess
+import tarfile
+import tempfile
+
+
+VERSION = "0.0.1"
+TAG = "py3-none-manylinux2014"
+
+
+def _get_pkg_info():
+    return (
+        f"""
+Metadata-Version: 2.1
+Name: curlinate
+Version: {VERSION}
+Summary: Command-line utility and Python library to simplify TLS fingerprint forgery
+Home-page: https://github.com/radian-software/curlinate
+Author: Radian LLC
+Maintainer: Radian LLC
+Maintainer-email: contact+curlinate@radian.codes
+License: MIT
+Download-URL: https://pypi.python.org/pypi/curlinate
+Project-URL: Bug Tracker, https://github.com/radian-software/curlinate/issues
+Project-URL: Documentation, https://github.com/radian-software/curlinate
+Project-URL: Source Code, https://github.com/radian-software/curlinate
+Requires-Python: >=3.8,<4.0
+            """.strip()
+        + "\n"
+    )
+
+
+def build_sdist(sdist_directory, *_):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        workdir = pathlib.Path(tmpdir) / f"curlinate-{VERSION}"
+        workdir.mkdir()
+        for fname in (
+            "pyproject.toml",
+            "pybuild/build.py",
+            "curlinate.py",
+            "curlinate.go",
+            "go.mod",
+            "go.sum",
+        ):
+            (workdir / fname).parent.mkdir(exist_ok=True, parents=True)
+            shutil.copyfile(fname, workdir / fname)
+        with open(workdir / "PKG-INFO", "w") as f:
+            f.write(_get_pkg_info())
+        tar_path = pathlib.Path(sdist_directory) / f"curlinate-{VERSION}.tar.gz"
+        with tarfile.open(tar_path, "w:gz") as tar:
+            tar.add(workdir, arcname=workdir.name)
+        return tar_path.name
+
+
+def walk(root: pathlib.Path):
+    yield root
+    if root.is_dir():
+        for child in root.iterdir():
+            yield from walk(child)
+
+
+def hash_file(fname: os.PathLike):
+    h = hashlib.sha256()
+    with open(fname, "rb") as f:
+        for chunk in iter(lambda: f.read(4096), b""):
+            h.update(chunk)
+    return base64.urlsafe_b64encode(h.digest()).decode().rstrip("=")
+
+
+def build_wheel(wheel_directory, *_, editable=False):
+    with tempfile.TemporaryDirectory() as tmpdir:
+        workdir = pathlib.Path(tmpdir)
+        dist_info = workdir / f"curlinate-{VERSION}.dist-info"
+        dist_info.mkdir()
+        scripts_dir = workdir / f"curlinate-{VERSION}.data" / "scripts"
+        scripts_dir.mkdir(parents=True)
+        if editable:
+            with open(workdir / "curlinate_editable.pth", "w") as f:
+                f.write(os.getcwd() + "\n")
+            subprocess.run(["go", "build", "."], check=True)
+            with open(scripts_dir / "curlinate", "w") as f:
+                f.write(
+                    f"""
+#!/bin/sh
+exec {shlex.quote(os.getcwd())}/curlinate "$@"
+                """.strip()
+                    + "\n"
+                )
+            (scripts_dir / "curlinate").chmod(0o755)
+        else:
+            shutil.copy("curlinate.py", workdir / "curlinate.py")
+            subprocess.run(
+                ["go", "build", "-o", scripts_dir / "curlinate", "."], check=True
+            )
+        with open(dist_info / "METADATA", "w") as f:
+            f.write(_get_pkg_info())
+        with open(dist_info / "WHEEL", "w") as f:
+            f.write(
+                f"""
+Wheel-Version: 1.0
+Generator: some horrifying bullshit you do not want to know about
+Root-Is-Purelib: false
+Tag: {TAG}
+            """.strip()
+                + "\n"
+            )
+        with open(dist_info / "RECORD", "w") as f:
+            for item in walk(workdir):
+                if not item.is_file():
+                    continue
+                if item.name == "RECORD":
+                    continue
+                f.write(
+                    ",".join(
+                        [
+                            str(item.relative_to(workdir)),
+                            "sha256=" + hash_file(item),
+                            str(item.stat().st_size),
+                        ]
+                    )
+                    + "\n"
+                )
+            f.write(f"{dist_info.relative_to(workdir)}/RECORD,,\n")
+        zip_base = pathlib.Path(wheel_directory) / f"curlinate-{VERSION}-{TAG}"
+        shutil.make_archive(str(zip_base), "zip", workdir)
+        # No way to set the output filename for shutil, must rename
+        # afterwards.
+        zip_path = zip_base.with_name(zip_base.name + ".zip")
+        whl_path = zip_base.with_name(zip_base.name + ".whl")
+        zip_path.rename(whl_path)
+        return whl_path.name
+
+
+def build_editable(wheel_directory, *args, **kwargs):
+    return build_wheel(wheel_directory, *args, **kwargs, editable=True)

curlinate-0.0.1/pyproject.toml

@@ -0,0 +1,5 @@
+[build-system]
+
+requires = []
+build-backend = "build"
+backend-path = ["pybuild"]