Browse Source
feat: Improve stability and performance for automatic captcha solver, fallback to manual captchapull/120/head v1.5.0
cacggghp
2 months ago
committed by
GitHub
GitHub
10 changed files with 1772 additions and 452 deletions
@ -0,0 +1,28 @@ |
|||||
|
name: "Close Stale Issues" |
||||
|
on: |
||||
|
schedule: |
||||
|
- cron: "0 0 * * 3" |
||||
|
workflow_dispatch: |
||||
|
|
||||
|
jobs: |
||||
|
stale: |
||||
|
permissions: |
||||
|
issues: write |
||||
|
runs-on: ubuntu-latest |
||||
|
steps: |
||||
|
- uses: actions/stale@997185467fa4f803885201cee163a9f38240193d # v10 |
||||
|
with: |
||||
|
repo-token: ${{ secrets.GITHUB_TOKEN }} |
||||
|
stale-issue-message: > |
||||
|
Привет! 👋 |
||||
|
<br><br> |
||||
|
Данный issue давно не обновлялся. Если в течение недели здесь не будет больше активности, issue будет закрыт. |
||||
|
<br><br> |
||||
|
Спасибо! |
||||
|
close-issue-message: "Issue был закрыт из-за отсутствия активности." |
||||
|
days-before-stale: 120 |
||||
|
days-before-close: 7 |
||||
|
operations-per-run: 1000 |
||||
|
ascending: true |
||||
|
enable-statistics: true |
||||
|
stale-issue-label: "Stale" |
||||
File diff suppressed because one or more lines are too long
File diff suppressed because it is too large
@ -0,0 +1,578 @@ |
|||||
|
package main |
||||
|
|
||||
|
import ( |
||||
|
"bytes" |
||||
|
"compress/gzip" |
||||
|
"context" |
||||
|
"encoding/json" |
||||
|
"errors" |
||||
|
"fmt" |
||||
|
"io" |
||||
|
"log" |
||||
|
"net" |
||||
|
"net/http" |
||||
|
"net/http/httputil" |
||||
|
neturl "net/url" |
||||
|
"os/exec" |
||||
|
"runtime" |
||||
|
"strings" |
||||
|
"time" |
||||
|
|
||||
|
"github.com/bschaatsbergen/dnsdialer" |
||||
|
) |
||||
|
|
||||
|
const captchaListenPort = "8765" |
||||
|
|
||||
|
type browserCommand struct { |
||||
|
name string |
||||
|
args []string |
||||
|
} |
||||
|
|
||||
|
func localCaptchaOrigin() string { |
||||
|
return "http://localhost:" + captchaListenPort |
||||
|
} |
||||
|
|
||||
|
func localCaptchaListenAddrs() []string { |
||||
|
return []string{ |
||||
|
"127.0.0.1:" + captchaListenPort, |
||||
|
"[::1]:" + captchaListenPort, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func localCaptchaHosts() []string { |
||||
|
return []string{ |
||||
|
"localhost:" + captchaListenPort, |
||||
|
"127.0.0.1:" + captchaListenPort, |
||||
|
"[::1]:" + captchaListenPort, |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func isLocalCaptchaHost(host string) bool { |
||||
|
for _, localHost := range localCaptchaHosts() { |
||||
|
if strings.EqualFold(host, localHost) { |
||||
|
return true |
||||
|
} |
||||
|
} |
||||
|
return false |
||||
|
} |
||||
|
|
||||
|
func localCaptchaURLForTarget(targetURL *neturl.URL) string { |
||||
|
localURL := &neturl.URL{ |
||||
|
Scheme: "http", |
||||
|
Host: "localhost:" + captchaListenPort, |
||||
|
Path: targetURL.Path, |
||||
|
RawPath: targetURL.RawPath, |
||||
|
RawQuery: targetURL.RawQuery, |
||||
|
} |
||||
|
if localURL.Path == "" { |
||||
|
localURL.Path = "/" |
||||
|
} |
||||
|
return localURL.String() |
||||
|
} |
||||
|
|
||||
|
func targetOrigin(targetURL *neturl.URL) string { |
||||
|
return targetURL.Scheme + "://" + targetURL.Host |
||||
|
} |
||||
|
|
||||
|
func rewriteProxyHeaderURL(raw string, targetURL *neturl.URL) string { |
||||
|
if raw == "" { |
||||
|
return raw |
||||
|
} |
||||
|
parsed, err := neturl.Parse(raw) |
||||
|
if err != nil { |
||||
|
return raw |
||||
|
} |
||||
|
if parsed.Scheme != "http" || !isLocalCaptchaHost(parsed.Host) { |
||||
|
return raw |
||||
|
} |
||||
|
parsed.Scheme = targetURL.Scheme |
||||
|
parsed.Host = targetURL.Host |
||||
|
return parsed.String() |
||||
|
} |
||||
|
|
||||
|
func rewriteProxyRequest(req *http.Request, targetURL *neturl.URL) { |
||||
|
req.URL.Scheme = targetURL.Scheme |
||||
|
req.URL.Host = targetURL.Host |
||||
|
if req.URL.Path == "" { |
||||
|
req.URL.Path = targetURL.Path |
||||
|
} |
||||
|
req.Host = targetURL.Host |
||||
|
|
||||
|
req.Header.Del("Accept-Encoding") |
||||
|
for _, headerName := range []string{"Origin", "Referer"} { |
||||
|
if rewritten := rewriteProxyHeaderURL(req.Header.Get(headerName), targetURL); rewritten != "" { |
||||
|
req.Header.Set(headerName, rewritten) |
||||
|
} else { |
||||
|
req.Header.Del(headerName) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func extractSuccessToken(body []byte) string { |
||||
|
var payload struct { |
||||
|
Response struct { |
||||
|
SuccessToken string `json:"success_token"` |
||||
|
} `json:"response"` |
||||
|
} |
||||
|
if err := json.Unmarshal(body, &payload); err != nil { |
||||
|
return "" |
||||
|
} |
||||
|
return payload.Response.SuccessToken |
||||
|
} |
||||
|
|
||||
|
func rewriteProxyCookies(header http.Header) { |
||||
|
cookies := (&http.Response{Header: header}).Cookies() |
||||
|
if len(cookies) == 0 { |
||||
|
return |
||||
|
} |
||||
|
header.Del("Set-Cookie") |
||||
|
for _, cookie := range cookies { |
||||
|
cookie.Domain = "" |
||||
|
cookie.Secure = false |
||||
|
cookie.Partitioned = false |
||||
|
if cookie.SameSite == http.SameSiteNoneMode || cookie.SameSite == http.SameSiteStrictMode { |
||||
|
cookie.SameSite = http.SameSiteLaxMode |
||||
|
} |
||||
|
header.Add("Set-Cookie", cookie.String()) |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func rewriteCaptchaHTML(html string, targetURL *neturl.URL) string { |
||||
|
localOrigin := localCaptchaOrigin() |
||||
|
upstreamOrigin := targetOrigin(targetURL) |
||||
|
html = strings.ReplaceAll(html, upstreamOrigin, localOrigin) |
||||
|
|
||||
|
script := fmt.Sprintf(` |
||||
|
<script> |
||||
|
(function() { |
||||
|
var localOrigin = %q; |
||||
|
var upstreamOrigin = %q; |
||||
|
|
||||
|
function rewriteUrl(urlStr) { |
||||
|
if (!urlStr || typeof urlStr !== 'string') return urlStr; |
||||
|
if (urlStr.indexOf(localOrigin) === 0) return urlStr; |
||||
|
if (urlStr.indexOf(upstreamOrigin) === 0) return localOrigin + urlStr.slice(upstreamOrigin.length); |
||||
|
if (urlStr.indexOf('//') === 0) {
|
||||
|
return '/generic_proxy?proxy_url=' + encodeURIComponent(window.location.protocol + urlStr); |
||||
|
} |
||||
|
if (urlStr.indexOf('http://') === 0 || urlStr.indexOf('https://') === 0) {
|
||||
|
return '/generic_proxy?proxy_url=' + encodeURIComponent(urlStr); |
||||
|
} |
||||
|
return urlStr; |
||||
|
} |
||||
|
|
||||
|
function rewriteElementAttr(el, attr) { |
||||
|
if (!el || !el.getAttribute) return; |
||||
|
var value = el.getAttribute(attr); |
||||
|
if (!value) return; |
||||
|
var rewritten = rewriteUrl(value); |
||||
|
if (rewritten !== value) { |
||||
|
el.setAttribute(attr, rewritten); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
function rewriteDocument(root) { |
||||
|
if (!root || !root.querySelectorAll) return; |
||||
|
root.querySelectorAll('[href]').forEach(function(el) { rewriteElementAttr(el, 'href'); }); |
||||
|
root.querySelectorAll('[src]').forEach(function(el) { rewriteElementAttr(el, 'src'); }); |
||||
|
root.querySelectorAll('form[action]').forEach(function(el) { rewriteElementAttr(el, 'action'); }); |
||||
|
} |
||||
|
|
||||
|
function handleSuccessToken(token) { |
||||
|
if (!token) return; |
||||
|
fetch('/local-captcha-result', { |
||||
|
method: 'POST', |
||||
|
headers: {'Content-Type': 'application/x-www-form-urlencoded'}, |
||||
|
body: 'token=' + encodeURIComponent(token) |
||||
|
}).then(function() { |
||||
|
document.body.innerHTML = '<h2 style="text-align:center;margin-top:20vh">Done! You can close the page.</h2>'; |
||||
|
setTimeout(function() { window.close(); }, 300); |
||||
|
}).catch(function() {}); |
||||
|
} |
||||
|
|
||||
|
var origOpen = XMLHttpRequest.prototype.open; |
||||
|
XMLHttpRequest.prototype.open = function() { |
||||
|
if (arguments[1] && typeof arguments[1] === 'string') { |
||||
|
this._origUrl = arguments[1]; |
||||
|
arguments[1] = rewriteUrl(arguments[1]); |
||||
|
} |
||||
|
return origOpen.apply(this, arguments); |
||||
|
}; |
||||
|
|
||||
|
var origSend = XMLHttpRequest.prototype.send; |
||||
|
XMLHttpRequest.prototype.send = function() { |
||||
|
var xhr = this; |
||||
|
if (this._origUrl && this._origUrl.indexOf('captchaNotRobot.check') !== -1) { |
||||
|
xhr.addEventListener('load', function() { |
||||
|
try { |
||||
|
var data = JSON.parse(xhr.responseText); |
||||
|
if (data.response && data.response.success_token) { |
||||
|
handleSuccessToken(data.response.success_token); |
||||
|
} |
||||
|
} catch (e) {} |
||||
|
}); |
||||
|
} |
||||
|
return origSend.apply(this, arguments); |
||||
|
}; |
||||
|
|
||||
|
var origFetch = window.fetch; |
||||
|
if (origFetch) { |
||||
|
window.fetch = function() { |
||||
|
var url = arguments[0]; |
||||
|
var isObj = (typeof url === 'object' && url && url.url); |
||||
|
var urlStr = isObj ? url.url : url; |
||||
|
var origUrlStr = urlStr; |
||||
|
|
||||
|
if (typeof urlStr === 'string') { |
||||
|
urlStr = rewriteUrl(urlStr); |
||||
|
arguments[0] = urlStr; |
||||
|
} |
||||
|
|
||||
|
var p = origFetch.apply(this, arguments); |
||||
|
if (typeof origUrlStr === 'string' && origUrlStr.indexOf('captchaNotRobot.check') !== -1) { |
||||
|
p.then(function(response) { |
||||
|
return response.clone().json(); |
||||
|
}).then(function(data) { |
||||
|
if (data.response && data.response.success_token) { |
||||
|
handleSuccessToken(data.response.success_token); |
||||
|
} |
||||
|
}).catch(function() {}); |
||||
|
} |
||||
|
return p; |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
document.addEventListener('submit', function(event) { |
||||
|
if (event.target && event.target.action) { |
||||
|
event.target.action = rewriteUrl(event.target.action); |
||||
|
} |
||||
|
}, true); |
||||
|
|
||||
|
document.addEventListener('click', function(event) { |
||||
|
var target = event.target && event.target.closest ? event.target.closest('a[href]') : null; |
||||
|
if (target && target.href) { |
||||
|
target.href = rewriteUrl(target.href); |
||||
|
} |
||||
|
}, true); |
||||
|
|
||||
|
var origFormSubmit = HTMLFormElement.prototype.submit; |
||||
|
HTMLFormElement.prototype.submit = function() { |
||||
|
if (this.action) { |
||||
|
this.action = rewriteUrl(this.action); |
||||
|
} |
||||
|
return origFormSubmit.apply(this, arguments); |
||||
|
}; |
||||
|
|
||||
|
var origWindowOpen = window.open; |
||||
|
if (origWindowOpen) { |
||||
|
window.open = function(url) { |
||||
|
if (typeof url === 'string') { |
||||
|
arguments[0] = rewriteUrl(url); |
||||
|
} |
||||
|
return origWindowOpen.apply(this, arguments); |
||||
|
}; |
||||
|
} |
||||
|
|
||||
|
rewriteDocument(document); |
||||
|
if (document.documentElement && window.MutationObserver) { |
||||
|
new MutationObserver(function(mutations) { |
||||
|
mutations.forEach(function(mutation) { |
||||
|
if (mutation.type === 'attributes' && mutation.target) { |
||||
|
rewriteElementAttr(mutation.target, mutation.attributeName); |
||||
|
return; |
||||
|
} |
||||
|
mutation.addedNodes.forEach(function(node) { |
||||
|
if (node.nodeType === 1) { |
||||
|
rewriteDocument(node); |
||||
|
} |
||||
|
}); |
||||
|
}); |
||||
|
}).observe(document.documentElement, { |
||||
|
subtree: true, |
||||
|
childList: true, |
||||
|
attributes: true, |
||||
|
attributeFilter: ['href', 'src', 'action'] |
||||
|
}); |
||||
|
} |
||||
|
})(); |
||||
|
</script> |
||||
|
`, localOrigin, upstreamOrigin) |
||||
|
|
||||
|
switch { |
||||
|
case strings.Contains(html, "</head>"): |
||||
|
return strings.Replace(html, "</head>", script+"</head>", 1) |
||||
|
case strings.Contains(html, "</body>"): |
||||
|
return strings.Replace(html, "</body>", script+"</body>", 1) |
||||
|
default: |
||||
|
return html + script |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func newCaptchaProxyTransport(dialer *dnsdialer.Dialer) *http.Transport { |
||||
|
transport := &http.Transport{ |
||||
|
MaxIdleConns: 100, |
||||
|
MaxIdleConnsPerHost: 100, |
||||
|
IdleConnTimeout: 90 * time.Second, |
||||
|
TLSHandshakeTimeout: 10 * time.Second, |
||||
|
ExpectContinueTimeout: 1 * time.Second, |
||||
|
ForceAttemptHTTP2: true, |
||||
|
} |
||||
|
if dialer != nil { |
||||
|
transport.DialContext = dialer.DialContext |
||||
|
} |
||||
|
return transport |
||||
|
} |
||||
|
|
||||
|
func startCaptchaServer(srv *http.Server, logPrefix string) error { |
||||
|
var listenErrs []string |
||||
|
var listening bool |
||||
|
|
||||
|
for _, addr := range localCaptchaListenAddrs() { |
||||
|
listener, err := net.Listen("tcp", addr) |
||||
|
if err != nil { |
||||
|
listenErrs = append(listenErrs, fmt.Sprintf("%s (%v)", addr, err)) |
||||
|
continue |
||||
|
} |
||||
|
listening = true |
||||
|
go func(listener net.Listener) { |
||||
|
if err := srv.Serve(listener); err != nil && !errors.Is(err, http.ErrServerClosed) { |
||||
|
log.Printf("%s: %s", logPrefix, err) |
||||
|
} |
||||
|
}(listener) |
||||
|
} |
||||
|
|
||||
|
if listening { |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
return fmt.Errorf("captcha listeners failed: %s", strings.Join(listenErrs, "; ")) |
||||
|
} |
||||
|
|
||||
|
// runCaptchaServerAndWait triggers the browser, and waiting gracefully for the solution token.
|
||||
|
func runCaptchaServerAndWait(handler http.Handler, captchaURL string, keyCh <-chan string, logPrefix string) (string, error) { |
||||
|
srv := &http.Server{Handler: handler} |
||||
|
|
||||
|
if err := startCaptchaServer(srv, logPrefix); err != nil { |
||||
|
return "", err |
||||
|
} |
||||
|
|
||||
|
fmt.Println("\n==============================================") |
||||
|
fmt.Println("ACTION REQUIRED: MANUAL CAPTCHA SOLVING NEEDED") |
||||
|
fmt.Println("Open this URL in your browser: " + captchaURL) |
||||
|
fmt.Println("==============================================") |
||||
|
fmt.Println() |
||||
|
openBrowser(captchaURL) |
||||
|
|
||||
|
key := <-keyCh |
||||
|
|
||||
|
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Second) |
||||
|
defer cancel() |
||||
|
if err := srv.Shutdown(ctx); err != nil { |
||||
|
return "", err |
||||
|
} |
||||
|
|
||||
|
return key, nil |
||||
|
} |
||||
|
|
||||
|
// notifyKey pushes the key string to the given channel without blocking
|
||||
|
func notifyKey(keyCh chan<- string, key string) { |
||||
|
if key != "" { |
||||
|
select { |
||||
|
case keyCh <- key: |
||||
|
default: |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func solveCaptchaViaHTTP(captchaImg string) (string, error) { |
||||
|
keyCh := make(chan string, 1) |
||||
|
mux := http.NewServeMux() |
||||
|
|
||||
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { |
||||
|
w.Header().Set("Content-Type", "text/html; charset=utf-8") |
||||
|
_, _ = fmt.Fprintf(w, `<!DOCTYPE html> |
||||
|
<html><head> |
||||
|
<meta name="viewport" content="width=device-width,initial-scale=1"> |
||||
|
<style>body{font-family:sans-serif;text-align:center;padding:20px} |
||||
|
img{max-width:100%%;margin:16px 0} |
||||
|
input{font-size:24px;padding:12px;width:80%%;box-sizing:border-box} |
||||
|
button{font-size:24px;padding:12px 32px;margin-top:12px;cursor:pointer}</style> |
||||
|
</head><body> |
||||
|
<h2>Solve the Captcha</h2> |
||||
|
<img src="%s" alt="captcha"/> |
||||
|
<form onsubmit="fetch('/solve?key='+encodeURIComponent(document.getElementById('k').value)).then(()=>{document.body.innerHTML='<h2>Done!</h2>';setTimeout(function(){window.close();}, 300);});return false;"> |
||||
|
<br><input id="k" type="text" autofocus placeholder="Text from image"/> |
||||
|
<br><button type="submit">Submit</button> |
||||
|
</form></body></html>`, captchaImg) |
||||
|
}) |
||||
|
|
||||
|
mux.HandleFunc("/solve", func(w http.ResponseWriter, r *http.Request) { |
||||
|
notifyKey(keyCh, r.URL.Query().Get("key")) |
||||
|
w.Header().Set("Content-Type", "text/html; charset=utf-8") |
||||
|
_, _ = fmt.Fprint(w, `<!DOCTYPE html><html><body><h2>Done!</h2></body></html>`) |
||||
|
}) |
||||
|
|
||||
|
return runCaptchaServerAndWait(mux, localCaptchaOrigin(), keyCh, "captcha HTTP server error") |
||||
|
} |
||||
|
|
||||
|
func solveCaptchaViaProxy(redirectURI string, dialer *dnsdialer.Dialer) (string, error) { |
||||
|
keyCh := make(chan string, 1) |
||||
|
|
||||
|
targetURL, err := neturl.Parse(redirectURI) |
||||
|
if err != nil { |
||||
|
return "", fmt.Errorf("invalid redirect URI: %v", err) |
||||
|
} |
||||
|
|
||||
|
transport := newCaptchaProxyTransport(dialer) |
||||
|
|
||||
|
proxy := &httputil.ReverseProxy{ |
||||
|
Transport: transport, |
||||
|
Rewrite: func(req *httputil.ProxyRequest) { |
||||
|
rewriteProxyRequest(req.Out, targetURL) |
||||
|
}, |
||||
|
ErrorHandler: func(w http.ResponseWriter, r *http.Request, err error) { |
||||
|
log.Printf("captcha proxy error for %s: %v", r.URL.String(), err) |
||||
|
w.Header().Set("Content-Type", "text/html; charset=utf-8") |
||||
|
w.WriteHeader(http.StatusBadGateway) |
||||
|
_, _ = fmt.Fprintf(w, `<!DOCTYPE html><html><body style="font-family:sans-serif;padding:20px"><h2>Captcha proxy error</h2><p>%v</p></body></html>`, err) |
||||
|
}, |
||||
|
ModifyResponse: func(res *http.Response) error { |
||||
|
rewriteProxyCookies(res.Header) |
||||
|
|
||||
|
if res.StatusCode >= 300 && res.StatusCode < 400 { |
||||
|
if loc := res.Header.Get("Location"); loc != "" { |
||||
|
if strings.HasPrefix(loc, "/") { |
||||
|
res.Header.Set("Location", loc) |
||||
|
} else if strings.HasPrefix(loc, targetOrigin(targetURL)) { |
||||
|
res.Header.Set("Location", strings.Replace(loc, targetOrigin(targetURL), localCaptchaOrigin(), 1)) |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
contentType := res.Header.Get("Content-Type") |
||||
|
shouldInspectBody := strings.Contains(contentType, "text/html") || strings.Contains(res.Request.URL.Path, "captchaNotRobot.check") |
||||
|
if !shouldInspectBody { |
||||
|
return nil |
||||
|
} |
||||
|
|
||||
|
reader := res.Body |
||||
|
if res.Header.Get("Content-Encoding") == "gzip" { |
||||
|
gzReader, err := gzip.NewReader(res.Body) |
||||
|
if err == nil { |
||||
|
reader = gzReader |
||||
|
defer func() { |
||||
|
if err := gzReader.Close(); err != nil { |
||||
|
log.Printf("failed to close gzip reader: %v", err) |
||||
|
} |
||||
|
}() |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
bodyBytes, err := io.ReadAll(reader) |
||||
|
if err != nil { |
||||
|
return err |
||||
|
} |
||||
|
if err := res.Body.Close(); err != nil { |
||||
|
return err |
||||
|
} |
||||
|
|
||||
|
if strings.Contains(res.Request.URL.Path, "captchaNotRobot.check") { |
||||
|
notifyKey(keyCh, extractSuccessToken(bodyBytes)) |
||||
|
} |
||||
|
|
||||
|
if strings.Contains(contentType, "text/html") { |
||||
|
for _, headerName := range []string{ |
||||
|
"Content-Security-Policy", |
||||
|
"Content-Security-Policy-Report-Only", |
||||
|
"X-Content-Security-Policy", |
||||
|
"X-WebKit-CSP", |
||||
|
"Cross-Origin-Opener-Policy", |
||||
|
"Cross-Origin-Embedder-Policy", |
||||
|
"Cross-Origin-Resource-Policy", |
||||
|
"X-Frame-Options", |
||||
|
} { |
||||
|
res.Header.Del(headerName) |
||||
|
} |
||||
|
|
||||
|
bodyBytes = []byte(rewriteCaptchaHTML(string(bodyBytes), targetURL)) |
||||
|
res.Header.Del("Content-Encoding") |
||||
|
} |
||||
|
|
||||
|
res.Body = io.NopCloser(bytes.NewReader(bodyBytes)) |
||||
|
res.ContentLength = int64(len(bodyBytes)) |
||||
|
res.Header.Set("Content-Length", fmt.Sprint(len(bodyBytes))) |
||||
|
|
||||
|
return nil |
||||
|
}, |
||||
|
} |
||||
|
|
||||
|
mux := http.NewServeMux() |
||||
|
mux.HandleFunc("/local-captcha-result", func(w http.ResponseWriter, r *http.Request) { |
||||
|
notifyKey(keyCh, r.FormValue("token")) // r.FormValue automatically parses the form
|
||||
|
w.Header().Set("Access-Control-Allow-Origin", "*") |
||||
|
_, _ = fmt.Fprint(w, "ok") |
||||
|
}) |
||||
|
|
||||
|
mux.HandleFunc("/generic_proxy", func(w http.ResponseWriter, r *http.Request) { |
||||
|
targetAuthUrl := r.URL.Query().Get("proxy_url") |
||||
|
targetParsed, err := neturl.Parse(targetAuthUrl) |
||||
|
if err != nil || targetParsed.Host == "" { |
||||
|
http.Error(w, "Bad URL", http.StatusBadRequest) |
||||
|
return |
||||
|
} |
||||
|
genericReverse := &httputil.ReverseProxy{ |
||||
|
Transport: transport, |
||||
|
Rewrite: func(req *httputil.ProxyRequest) { |
||||
|
req.Out.URL.Path = targetParsed.Path |
||||
|
req.Out.URL.RawQuery = targetParsed.RawQuery |
||||
|
rewriteProxyRequest(req.Out, targetParsed) |
||||
|
}, |
||||
|
} |
||||
|
genericReverse.ServeHTTP(w, r) |
||||
|
}) |
||||
|
|
||||
|
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) { |
||||
|
if r.URL.Path == "/" && targetURL.Path != "" && targetURL.Path != "/" && r.URL.RawQuery == "" { |
||||
|
http.Redirect(w, r, localCaptchaURLForTarget(targetURL), http.StatusTemporaryRedirect) |
||||
|
return |
||||
|
} |
||||
|
proxy.ServeHTTP(w, r) |
||||
|
}) |
||||
|
|
||||
|
return runCaptchaServerAndWait(mux, localCaptchaURLForTarget(targetURL), keyCh, "proxy HTTP server error") |
||||
|
} |
||||
|
|
||||
|
func openBrowser(url string) { |
||||
|
for _, cmd := range browserOpenCommands(runtime.GOOS, url) { |
||||
|
if err := exec.Command(cmd.name, cmd.args...).Start(); err == nil { |
||||
|
return |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
func browserOpenCommands(goos string, url string) []browserCommand { |
||||
|
switch goos { |
||||
|
case "windows": |
||||
|
return []browserCommand{{name: "cmd", args: []string{"/c", "start", url}}} |
||||
|
case "darwin": |
||||
|
return []browserCommand{{name: "open", args: []string{url}}} |
||||
|
case "linux": |
||||
|
return []browserCommand{ |
||||
|
{name: "xdg-open", args: []string{url}}, |
||||
|
{name: "gio", args: []string{"open", url}}, |
||||
|
} |
||||
|
case "android": |
||||
|
return []browserCommand{ |
||||
|
{name: "termux-open-url", args: []string{url}}, |
||||
|
{name: "/system/bin/am", args: []string{"start", "-a", "android.intent.action.VIEW", "-d", url}}, |
||||
|
{name: "am", args: []string{"start", "-a", "android.intent.action.VIEW", "-d", url}}, |
||||
|
{name: "xdg-open", args: []string{url}}, |
||||
|
} |
||||
|
case "ios": |
||||
|
return []browserCommand{ |
||||
|
{name: "open", args: []string{url}}, |
||||
|
{name: "uiopen", args: []string{url}}, |
||||
|
} |
||||
|
} |
||||
|
return nil |
||||
|
} |
||||
Loading…
Reference in new issue