frp

frp è un progetto open source il cui sviluppo continuo è reso possibile interamente dal supporto dei nostri fantastici sponsor. Se desideri unirti a loro, ti invitiamo a considerare di sponsorizzare lo sviluppo di frp.

Gold Sponsors

L'IDE completo progettato per sviluppatori Go professionisti

# ./confd/test.toml [[proxies]] name = "ssh" type = "tcp" localIP = "127.0.0.1" localPort = 22 remotePort = 6000 ``` ### Server Dashboard Controlla lo stato di frp e le statistiche dei proxy tramite la Dashboard. Configura una porta per la dashboard per abilitare questa funzionalità:```toml # The default value is 127.0.0.1. Change it to 0.0.0.0 when you want to access it from a public network. webServer.addr = "0.0.0.0" webServer.port = 7500 # dashboard's username and password are both optional webServer.user = "admin" webServer.password = "admin" ``` Poi visita `http://[serverAddr]:7500` per vedere la dashboard, con nome utente e password entrambi `admin`. Inoltre, puoi utilizzare la porta HTTPS usando il certificato SSL wildcard o normale dei tuoi domini:```toml webServer.port = 7500 # dashboard's username and password are both optional webServer.user = "admin" webServer.password = "admin" webServer.tls.certFile = "server.crt" webServer.tls.keyFile = "server.key" ``` Poi visita `https://[serverAddr]:7500` per vedere la dashboard in connessione HTTPS sicura, con nome utente e password entrambi `admin`. ![dashboard](https://assets.kitploit.com/production/public/readmes/3770/0f836cc321c1fd65416940b5e12ca576cccc68f12d61ff045a09582ccfff74c1.png) ### Interfaccia Admin del Client L'Interfaccia Admin del Client ti aiuta a controllare e gestire la configurazione e i proxy di frpc. Configura un indirizzo per l'interfaccia admin per abilitare questa funzionalità:```toml webServer.addr = "127.0.0.1" webServer.port = 7400 webServer.user = "admin" webServer.password = "admin" ``` Poi visita `http://127.0.0.1:7400` per vedere l'interfaccia di amministrazione, con nome utente e password entrambi `admin`. #### Gestione dinamica dei proxy (Store) Puoi creare, aggiornare ed eliminare dinamicamente proxy e visitatori in fase di esecuzione tramite l'interfaccia Web o l'API, senza riavviare frpc. Per abilitare questa funzionalità, configura `store.path` per specificare un file in cui persistere le configurazioni:```toml [store] path = "./db.json" ``` I proxy e i visitatori gestiti tramite lo Store vengono salvati su disco e ripristinati automaticamente al riavvio di frpc. Funzionano insieme ai proxy definiti nel file di configurazione — le voci dello Store hanno precedenza in caso di conflitto di nomi. ### Monitor Quando il server web è abilitato, frps salverà i dati di monitoraggio nella cache per 7 giorni. Verranno cancellati dopo il riavvio del processo. È supportato anche Prometheus. #### Prometheus Abilita prima la dashboard, poi configura `enablePrometheus = true` in `frps.toml`. `http://{dashboard_addr}/metrics` fornirà i dati di monitoraggio di Prometheus. ### Autenticazione del Client Esistono 2 metodi di autenticazione per autenticare frpc con frps. Puoi decidere quale utilizzare configurando `auth.method` in `frpc.toml` e `frps.toml`; quello predefinito è token. Configurando `auth.additionalScopes = ["HeartBeats"]` si utilizzerà il metodo di autenticazione configurato per aggiungere e validare l'autenticazione su ogni heartbeat tra frpc e frps. Configurando `auth.additionalScopes = ["NewWorkConns"]` si farà lo stesso per ogni nuova connessione di lavoro tra frpc e frps. #### Autenticazione tramite Token Quando si specifica `auth.method = "token"` in `frpc.toml` e `frps.toml` — verrà utilizzata l'autenticazione basata su token. Assicurati di specificare lo stesso `auth.token` in `frps.toml` e `frpc.toml` affinché frpc superi la validazione di frps. ##### Sorgente del Token frp supporta la lettura dei token di autenticazione da sorgenti esterne utilizzando la configurazione `tokenSource`. Attualmente è supportata la sorgente di token basata su file. **Sorgente di token basata su file:**```toml # frpc.toml auth.method = "token" auth.tokenSource.type = "file" auth.tokenSource.file.path = "/path/to/token/file" ``` Il token verrà letto dal file specificato all'avvio. Questo è utile per scenari in cui i token sono gestiti da sistemi esterni o devono essere mantenuti separati dai file di configurazione per motivi di sicurezza. #### Autenticazione OIDC Quando si specifica `auth.method = "oidc"` in `frpc.toml` e `frps.toml` - verrà utilizzata l'autenticazione basata su OIDC. OIDC sta per OpenID Connect, e il flusso utilizzato è chiamato [Client Credentials Grant](https://tools.ietf.org/html/rfc6749#section-4.4). Per utilizzare questo tipo di autenticazione - configura `frpc.toml` e `frps.toml` come segue:```toml # frps.toml auth.method = "oidc" auth.oidc.issuer = "https://example-oidc-issuer.com/" auth.oidc.audience = "https://oidc-audience.com/.default" ``` ``` ## 🛠️ Caratteristiche - **Analisi statica**: esamina il codice sorgente senza eseguirlo, rilevando vulnerabilità come SQL injection, XSS e problemi di gestione della memoria. - **Analisi dinamica**: esegue l'applicazione in un ambiente controllato per osservare il comportamento a runtime e identificare problemi di sicurezza. - **Scansione delle dipendenze**: verifica le librerie di terze parti per individuare versioni obsolete o vulnerabilità note. - **Report dettagliati**: genera report completi con descrizioni delle vulnerabilità, livelli di gravità e suggerimenti per la correzione. - **Integrazione CI/CD**: si integra perfettamente con pipeline di integrazione continua e distribuzione continua per automatizzare i controlli di sicurezza. - **Interfaccia a riga di comando**: offre un'interfaccia CLI potente e flessibile per l'uso in script e automazioni. - **Supporto multi-linguaggio**: supporta un'ampia gamma di linguaggi di programmazione, tra cui Python, JavaScript, Java, C/C++ e altri. - **Regole personalizzabili**: consente di definire regole di sicurezza personalizzate per adattarsi alle esigenze specifiche del progetto. - **Modalità silenziosa**: esegue la scansione senza output interattivo, ideale per ambienti headless o CI. - **Aggiornamenti automatici**: mantiene aggiornato il database delle vulnerabilità con aggiornamenti automatici regolari. ``````toml # frpc.toml auth.method = "oidc" auth.oidc.clientID = "98692467-37de-409a-9fac-bb2585826f18" # Replace with OIDC client ID auth.oidc.clientSecret = "oidc_secret" auth.oidc.audience = "https://oidc-audience.com/.default" auth.oidc.tokenEndpointURL = "https://example-oidc-endpoint.com/oauth2/v2.0/token" ``` ### Crittografia e Compressione Le funzionalità sono disattivate per impostazione predefinita. Puoi attivare la crittografia e/o la compressione:```toml # frpc.toml [[proxies]] name = "ssh" type = "tcp" localPort = 22 remotePort = 6000 transport.useEncryption = true transport.useCompression = true ``` #### TLS A partire dalla v0.50.0, il valore predefinito di `transport.tls.enable` e `transport.tls.disableCustomTLSFirstByte` è stato modificato in true, e TLS è abilitato per impostazione predefinita. Per il multiplexing delle porte, frp invia un primo byte `0x17` per stabilire una connessione TLS. Questo ha effetto solo quando imposti `transport.tls.disableCustomTLSFirstByte` su false. Per **imporre** a `frps` di accettare solo connessioni TLS - configura `transport.tls.force = true` in `frps.toml`. **Questo è opzionale.** **Impostazioni TLS di `frpc`:**```toml transport.tls.enable = true transport.tls.certFile = "certificate.crt" transport.tls.keyFile = "certificate.key" transport.tls.trustedCaFile = "ca.crt" ``` **`frps` Impostazioni TLS:**```toml transport.tls.force = true transport.tls.certFile = "certificate.crt" transport.tls.keyFile = "certificate.key" transport.tls.trustedCaFile = "ca.crt" ``` Avrai bisogno di **un certificato CA radice** e **di almeno un certificato SSL/TLS**. **Può** essere autofirmato o regolare (come Let's Encrypt o un altro provider di certificati SSL/TLS). Se utilizzi `frp` tramite indirizzo IP e non tramite hostname, assicurati di impostare l'indirizzo IP appropriato nell'area Subject Alternative Name (SAN) durante la generazione dei certificati SSL/TLS. Ad esempio: * Prepara il file di configurazione di openssl. Si trova in `/etc/pki/tls/openssl.cnf` sui sistemi Linux e in `/System/Library/OpenSSL/openssl.cnf` su MacOS, e puoi copiarlo nel percorso corrente, ad esempio `cp /etc/pki/tls/openssl.cnf ./my-openssl.cnf`. Se non è presente, puoi crearlo tu stesso, ad esempio:``` cat > my-openssl.cnf << EOF [ ca ] default_ca = CA_default [ CA_default ] x509_extensions = usr_cert [ req ] default_bits = 2048 default_md = sha256 default_keyfile = privkey.pem distinguished_name = req_distinguished_name attributes = req_attributes x509_extensions = v3_ca string_mask = utf8only [ req_distinguished_name ] [ req_attributes ] [ usr_cert ] basicConstraints = CA:FALSE nsComment = "OpenSSL Generated Certificate" subjectKeyIdentifier = hash authorityKeyIdentifier = keyid,issuer [ v3_ca ] subjectKeyIdentifier = hash authorityKeyIdentifier = keyid:always,issuer basicConstraints = CA:true EOF ``` * crea i certificati CA:``` openssl genrsa -out ca.key 2048 openssl req -x509 -new -nodes -key ca.key -subj "/CN=example.ca.com" -days 5000 -out ca.crt ``` * compilare i certificati frps:``` openssl genrsa -out server.key 2048 openssl req -new -sha256 -key server.key \ -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=server.com" \ -reqexts SAN \ -config <(cat my-openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com")) \ -out server.csr openssl x509 -req -days 365 -sha256 \ -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial \ -extfile <(printf "subjectAltName=DNS:localhost,IP:127.0.0.1,DNS:example.server.com") \ -out server.crt ``` * compila i certificati frpc：``` openssl genrsa -out client.key 2048 openssl req -new -sha256 -key client.key \ -subj "/C=XX/ST=DEFAULT/L=DEFAULT/O=DEFAULT/CN=client.com" \ -reqexts SAN \ -config <(cat my-openssl.cnf <(printf "\n[SAN]\nsubjectAltName=DNS:client.com,DNS:example.client.com")) \ -out client.csr openssl x509 -req -days 365 -sha256 \ -in client.csr -CA ca.crt -CAkey ca.key -CAcreateserial \ -extfile <(printf "subjectAltName=DNS:client.com,DNS:example.client.com") \ -out client.crt ``` ### Ricaricamento a caldo della configurazione di frpc I campi `webServer` sono necessari per abilitare l'API HTTP:```toml # frpc.toml webServer.addr = "127.0.0.1" webServer.port = 7400 ``` Quindi esegui il comando `frpc reload -c ./frpc.toml` e attendi circa 10 secondi per consentire a `frpc` di creare, aggiornare o rimuovere i proxy. **Nota che i parametri globali del client non verranno modificati tranne 'start'.** `start` è una lista bianca globale valutata dopo che tutte le sorgenti sono state unite (file di configurazione/include/store). Se `start` non è vuoto, qualsiasi proxy o visitor non elencato non verrà avviato, incluse le voci create tramite Store API. `start` è mantenuto principalmente per compatibilità e generalmente non è raccomandato per le nuove configurazioni. Preferisci `enabled` per-proxy/per-visitor e mantieni `start` vuoto a meno che tu non voglia esplicitamente questo comportamento di lista bianca globale. Puoi eseguire il comando `frpc verify -c ./frpc.toml` prima del reload per verificare se ci sono errori di configurazione. ### Ottenere lo stato dei proxy dal client Usa `frpc status -c ./frpc.toml` per ottenere lo stato di tutti i proxy. I campi `webServer` sono richiesti per abilitare l'API HTTP. ### Consentire solo determinate porte sul server `allowPorts` in `frps.toml` viene utilizzato per evitare l'abuso delle porte:```toml # frps.toml allowPorts = [ { start = 2000, end = 3000 }, { single = 3001 }, { single = 3003 }, { start = 4000, end = 50000 } ] ``` ### Riutilizzo della Porta `vhostHTTPPort` e `vhostHTTPSPort` in frps possono utilizzare la stessa porta di `bindPort`. frps rileverà il protocollo della connessione e lo gestirà di conseguenza. Ciò a cui devi prestare attenzione è che, se vuoi configurare `vhostHTTPSPort` e `bindPort` sulla stessa porta, devi prima impostare `transport.tls.disableCustomTLSFirstByte` su false. In futuro vorremmo provare a consentire a più proxy di associare la stessa porta remota con protocolli diversi. ### Limite di Larghezza di Banda #### Per Ogni Proxy```toml # frpc.toml [[proxies]] name = "ssh" type = "tcp" localPort = 22 remotePort = 6000 transport.bandwidthLimit = "1MB" ``` Imposta `transport.bandwidthLimit` nella configurazione di ciascun proxy per abilitare questa funzionalità. Le unità supportate sono `MB` e `KB`. Imposta `transport.bandwidthLimitMode` su `client` o `server` per limitare la larghezza di banda sul lato client o server. Il valore predefinito è `client`. ### Multiplexing del flusso TCP frp supporta il multiplexing del flusso TCP dalla versione v0.10.0, simile al Multiplexing HTTP2, in cui tutte le connessioni logiche allo stesso frpc vengono multiplexate nella stessa connessione TCP. Puoi disabilitare questa funzionalità modificando `frps.toml` e `frpc.toml`:```toml # frps.toml and frpc.toml, must be same transport.tcpMux = false ``` ### Supporto del protocollo KCP KCP è un protocollo veloce e affidabile che può ottenere un effetto di trasmissione con una riduzione della latenza media dal 30% al 40% e una riduzione del ritardo massimo di un fattore tre, al costo di un dispendio di banda maggiore del 10% al 20% rispetto a TCP. La modalità KCP utilizza UDP come trasporto sottostante. Utilizzo di KCP in frp: 1. Abilita KCP in frps: ```toml # frps.toml bindPort = 7000 # Specify a UDP port for KCP. kcpBindPort = 7000 ``` Il numero `kcpBindPort` può essere lo stesso di `bindPort`, poiché il campo `bindPort` specifica una porta TCP. 2. Configura `frpc.toml` per utilizzare KCP per connettersi a frps: ```toml # frpc.toml serverAddr = "x.x.x.x" # Same as the 'kcpBindPort' in frps.toml serverPort = 7000 transport.protocol = "kcp" ``` ### Supporto al protocollo QUIC QUIC è un nuovo trasporto multiplexed costruito sopra UDP. Utilizzo di QUIC in frp: 1. Abilita QUIC in frps: ```toml # frps.toml bindPort = 7000 # Specify a UDP port for QUIC. quicBindPort = 7000 ``` Il numero `quicBindPort` può essere lo stesso di `bindPort`, poiché il campo `bindPort` specifica una porta TCP. 2. Configura `frpc.toml` per utilizzare QUIC per connettersi a frps: ```toml # frpc.toml serverAddr = "x.x.x.x" # Same as the 'quicBindPort' in frps.toml serverPort = 7000 transport.protocol = "quic" ``` ### Connection Pooling Per impostazione predefinita, frps crea una nuova connessione frpc al servizio backend a ogni richiesta dell'utente. Con il connection pooling, frps mantiene un certo numero di connessioni pre-stabilite, riducendo il tempo necessario per stabilire una connessione. Questa funzionalità è adatta a un gran numero di connessioni brevi. 1. Configurare il limite del numero di connessioni del pool che ogni proxy può utilizzare in `frps.toml`: ```toml # frps.toml transport.maxPoolCount = 5 ``` 2. Abilita e specifica il numero di connection pool: ```toml # frpc.toml transport.poolCount = 1 ``` ### Bilanciamento del carico Il bilanciamento del carico è supportato da `group`. Questa funzionalità è attualmente disponibile solo per i tipi `tcp`, `http`, `tcpmux`.```toml # frpc.toml [[proxies]] name = "test1" type = "tcp" localPort = 8080 remotePort = 80 loadBalancer.group = "web" loadBalancer.groupKey = "123" [[proxies]] name = "test2" type = "tcp" localPort = 8081 remotePort = 80 loadBalancer.group = "web" loadBalancer.groupKey = "123" ``` `loadBalancer.groupKey` viene utilizzato per l'autenticazione. Le connessioni alla porta 80 verranno distribuite casualmente ai proxy dello stesso gruppo. Per il tipo `tcp`, `remotePort` nello stesso gruppo deve essere lo stesso. Per il tipo `http`, `customDomains`, `subdomain`, `locations` devono essere gli stessi. ### Controllo di integrità del servizio La funzione di controllo di integrità può aiutarti a ottenere alta disponibilità con il bilanciamento del carico. Aggiungi `healthCheck.type = "tcp"` o `healthCheck.type = "http"` per abilitare il controllo di integrità. Con il tipo di controllo di integrità **tcp**, la porta del servizio verrà sottoposta a ping (TCPing):```toml # frpc.toml [[proxies]] name = "test1" type = "tcp" localPort = 22 remotePort = 6000 # Enable TCP health check healthCheck.type = "tcp" # TCPing timeout seconds healthCheck.timeoutSeconds = 3 # If health check failed 3 times in a row, the proxy will be removed from frps healthCheck.maxFailed = 3 # A health check every 10 seconds healthCheck.intervalSeconds = 10 ``` Con il tipo di health check **http**, verrà inviata una richiesta HTTP al servizio e ci si aspetta una risposta HTTP 2xx OK:```toml # frpc.toml [[proxies]] name = "web" type = "http" localIP = "127.0.0.1" localPort = 80 customDomains = ["test.example.com"] # Enable HTTP health check healthCheck.type = "http" # frpc will send a GET request to '/status' # and expect an HTTP 2xx OK response healthCheck.path = "/status" healthCheck.timeoutSeconds = 3 healthCheck.maxFailed = 3 healthCheck.intervalSeconds = 10 ``` ### Riscrittura dell'Header HTTP Host Per impostazione predefinita, frp non modifica affatto le richieste HTTP in tunnel, poiché si tratta di una copia byte per byte. Tuttavia, parlando di server web e richieste HTTP, il tuo server web potrebbe fare affidamento sull'header HTTP `Host` per determinare il sito web a cui accedere. frp può riscrivere l'header `Host` quando inoltra le richieste HTTP, tramite il campo `hostHeaderRewrite`:```toml # frpc.toml [[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["test.example.com"] hostHeaderRewrite = "dev.example.com" ``` The HTTP request will have the `Host` header rewritten to `Host: dev.example.com` when it reaches the actual web server, although the request from the browser probably has `Host: test.example.com`. ### Setting other HTTP Headers Similar to `Host`, You can override other HTTP request and response headers with proxy type `http`.```toml # frpc.toml [[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["test.example.com"] hostHeaderRewrite = "dev.example.com" requestHeaders.set.x-from-where = "frp" responseHeaders.set.foo = "bar" ``` In questo esempio, imposterà l'header `x-from-where: frp` nella richiesta HTTP e `foo: bar` nella risposta HTTP. ### Ottenere l'IP reale #### HTTP X-Forwarded-For Questa funzionalità è per i proxy `http` o per i proxy con i plugin `https2http` e `https2https` abilitati. Puoi ottenere l'IP reale dell'utente dagli header della richiesta HTTP `X-Forwarded-For`. #### Proxy Protocol frp supporta il Proxy Protocol per inviare l'IP reale dell'utente ai servizi locali. Ecco un esempio per il servizio https:```toml # frpc.toml [[proxies]] name = "web" type = "https" localPort = 443 customDomains = ["test.example.com"] # now v1 and v2 are supported transport.proxyProtocolVersion = "v2" ``` Puoi abilitare il supporto Proxy Protocol in nginx per esporre l'IP reale dell'utente nell'header HTTP `X-Real-IP`, e poi leggere l'header `X-Real-IP` nel tuo servizio web per ottenere l'IP reale. ### Richiedi HTTP Basic Auth (Password) per i Servizi Web Chiunque riesca a indovinare l'URL del tuo tunnel può accedere al tuo server web locale, a meno che non lo proteggi con una password. Questo impone HTTP Basic Auth su tutte le richieste con il nome utente e la password specificati nel file di configurazione di frpc. Può essere abilitato solo quando il tipo di proxy è http.```toml # frpc.toml [[proxies]] name = "web" type = "http" localPort = 80 customDomains = ["test.example.com"] httpUser = "abc" httpPassword = "abc" ``` Visita `http://test.example.com` nel browser e ora ti viene richiesto di inserire nome utente e password. ### Nomi di Sottodominio Personalizzati È conveniente usare la configurazione `subdomain` per i tipi http e https quando molte persone condividono un unico server frps.```toml # frps.toml subDomainHost = "frps.com" ``` Risolvi `*.frps.com` all'IP del server frps. Questa viene solitamente chiamata record DNS Wildcard.```toml # frpc.toml [[proxies]] name = "web" type = "http" localPort = 80 subdomain = "test" ``` Ora puoi visitare il tuo servizio web su `test.frps.com`. Nota che se `subdomainHost` non è vuoto, `customDomains` non dovrebbe essere il sottodominio di `subdomainHost`. ### Routing degli URL frp supporta l'inoltro delle richieste HTTP a diversi servizi web backend tramite il routing degli URL. `locations` specifica il prefisso dell'URL utilizzato per il routing. frps cerca prima il prefisso più specifico indicato da stringhe letterali, indipendentemente dall'ordine elencato.```toml # frpc.toml [[proxies]] name = "web01" type = "http" localPort = 80 customDomains = ["web.example.com"] locations = ["/"] [[proxies]] name = "web02" type = "http" localPort = 81 customDomains = ["web.example.com"] locations = ["/news", "/about"] ``` Le richieste HTTP con prefisso URL `/news` o `/about` verranno inoltrate a **web02** e le altre richieste a **web01**. ### Multiplexing delle porte TCP frp supporta la ricezione di socket TCP indirizzati a diversi proxy su una singola porta su frps, simile a `vhostHTTPPort` e `vhostHTTPSPort`. L'unico metodo di multiplexing delle porte TCP attualmente supportato è `httpconnect` - tunnel HTTP CONNECT. Quando si imposta `tcpmuxHTTPConnectPort` su un valore diverso da 0 in frps, frps ascolterà su questa porta le richieste HTTP CONNECT. L'host della richiesta HTTP CONNECT verrà utilizzato per abbinare il proxy in frps. Gli host dei proxy possono essere configurati in frpc configurando `customDomains` e/o `subdomain` sotto i proxy `tcpmux`, quando `multiplexer = "httpconnect"`. Ad esempio:```toml # frps.toml bindPort = 7000 tcpmuxHTTPConnectPort = 1337 ``` ``` ## 🛡️ Caratteristiche - **Rilevamento in tempo reale**: Monitora continuamente le attività di rete per identificare potenziali minacce. - **Analisi avanzata**: Utilizza algoritmi di apprendimento automatico per rilevare anomalie. - **Interfaccia intuitiva**: Dashboard facile da usare per visualizzare avvisi e report. - **Integrazione perfetta**: Funziona con gli strumenti di sicurezza esistenti. - **Open Source**: Gratuito da usare e modificare, con una community attiva. ``````toml # frpc.toml serverAddr = "x.x.x.x" serverPort = 7000 [[proxies]] name = "proxy1" type = "tcpmux" multiplexer = "httpconnect" customDomains = ["test1"] localPort = 80 [[proxies]] name = "proxy2" type = "tcpmux" multiplexer = "httpconnect" customDomains = ["test2"] localPort = 8080 ``` Nella configurazione sopra riportata - frps può essere contattato sulla porta 1337 con un header HTTP CONNECT come:``` CONNECT test1 HTTP/1.1\r\n\r\n ``` e la connessione verrà instradata verso `proxy1`. ### Connessione a frps tramite PROXY frpc può connettersi a frps tramite proxy se si imposta la variabile d'ambiente `HTTP_PROXY` del sistema operativo, oppure se `transport.proxyURL` è impostato nel file frpc.toml. Funziona solo quando il protocollo è tcp.```toml # frpc.toml serverAddr = "x.x.x.x" serverPort = 7000 transport.proxyURL = "http://user:[email protected]:8080" ``` ### Mappatura degli intervalli di porte *Aggiunto nella v0.56.0* Possiamo usare la sintassi degli intervalli dei template Go combinata con la funzione integrata `parseNumberRangePair` per ottenere la mappatura degli intervalli di porte. L'esempio seguente, quando eseguito, creerà 8 proxy denominati `test-6000, test-6001 ... test-6007`, ciascuno mappando la porta remota alla porta locale.``` {{- range $_, $v := parseNumberRangePair "6000-6006,6007" "6000-6006,6007" }} [[proxies]] name = "tcp-{{ $v.First }}" type = "tcp" localPort = {{ $v.First }} remotePort = {{ $v.Second }} {{- end }} ``` ### Plugin Client Di default, frpc inoltra le richieste solo verso porte TCP o UDP locali. I plugin vengono utilizzati per fornire funzionalità avanzate. Sono disponibili plugin integrati come `unix_domain_socket`, `http_proxy`, `socks5`, `static_file`, `http2https`, `https2http`, `https2https` e puoi vedere [esempi di utilizzo](#example-usage). Utilizzo del plugin **http_proxy**:```toml # frpc.toml [[proxies]] name = "http_proxy" type = "tcp" remotePort = 6000 [proxies.plugin] type = "http_proxy" httpUser = "abc" httpPassword = "abc" ``` `httpUser` e `httpPassword` sono parametri di configurazione utilizzati nel plugin `http_proxy`. ### Plugin di gestione del server Leggi il [documento](https://github.com/fatedier/frp/blob/HEAD/doc/server_plugin.md). Trova altri plugin in [gofrp/plugin](https://github.com/gofrp/plugin). ### Gateway tunnel SSH *aggiunto in v0.53.0* frp supporta l'ascolto di una porta SSH sul lato frps e realizza il proxy del protocollo TCP tramite il protocollo SSH -R, senza dipendere da frpc.```toml # frps.toml sshTunnelGateway.bindPort = 2200 ``` Quando si esegue `./frps -c frps.toml`, un file di chiave privata denominato `.autogen_ssh_key` verrà creato automaticamente nella directory di lavoro corrente. Questo file di chiave privata generato verrà utilizzato dal server SSH in frps. Eseguendo il comando```bash ssh -R :80:127.0.0.1:8080 v0@{frp address} -p 2200 tcp --proxy_name "test-tcp" --remote_port 9090 ``` imposta un proxy su frps che inoltra il servizio locale 8080 alla porta 9090.```bash frp (via SSH) (Ctrl+C to quit) User: ProxyName: test-tcp Type: tcp RemoteAddress: :9090 ``` Questo equivale a:```bash frpc tcp --proxy_name "test-tcp" --local_ip 127.0.0.1 --local_port 8080 --remote_port 9090 ``` Fare riferimento a questo [documento](https://github.com/fatedier/frp/blob/HEAD/doc/ssh_tunnel_gateway.md) per maggiori informazioni. ### Rete Virtuale (VirtualNet) *Funzionalità Alpha aggiunta nella v0.62.0* La funzionalità VirtualNet consente a frp di creare e gestire connessioni di rete virtuali tra client e visitatori tramite un'interfaccia TUN. Ciò permette il routing a livello IP tra macchine, estendendo frp oltre il semplice inoltro delle porte per supportare la piena connettività di rete. Per informazioni dettagliate su configurazione e utilizzo, fare riferimento alla [documentazione VirtualNet](https://github.com/fatedier/frp/blob/HEAD/doc/virtual_net.md). ## Feature Gates frp supporta i feature gate per abilitare o disabilitare funzionalità sperimentali. Ciò consente agli utenti di provare nuove funzionalità prima che siano considerate stabili. ### Feature Gates Disponibili | Nome | Fase | Predefinito | Descrizione | |------|-------|---------|-------------| | VirtualNet | ALPHA | false | Capacità di rete virtuale per frp | ### Abilitazione dei Feature Gates Per abilitare una funzionalità sperimentale, aggiungi il feature gate alla tua configurazione:```toml featureGates = { VirtualNet = true } ``` ### Ciclo di vita delle funzionalità Le funzionalità attraversano tipicamente tre fasi: 1. **ALPHA**: Disabilitata per impostazione predefinita, potrebbe essere instabile 2. **BETA**: Può essere abilitata per impostazione predefinita, più stabile ma ancora in evoluzione 3. **GA (Generally Available)**: Abilitata per impostazione predefinita, pronta per l'uso in produzione ## Progetti correlati * [gofrp/plugin](https://github.com/gofrp/plugin) - Un repository per i plugin di frp che contiene una varietà di plugin implementati sulla base del meccanismo di estensione di frp, soddisfacendo le esigenze di personalizzazione di diversi scenari. * [gofrp/tiny-frpc](https://github.com/gofrp/tiny-frpc) - Una versione leggera del client frp (circa 3,5MB al minimo) implementata utilizzando il protocollo ssh, che supporta alcune delle funzionalità più comunemente utilizzate, adatta a dispositivi con risorse limitate. ## Contribuire Ti interessa partecipare? Vorremmo aiutarti! * Dai un'occhiata alla nostra [lista di issues](https://github.com/fatedier/frp/issues) e considera l'invio di una Pull Request al **ramo dev**. * Se vuoi aggiungere una nuova funzionalità, crea prima un'issue per descrivere la nuova funzionalità e l'approccio di implementazione. Una volta accettata la proposta, crea un'implementazione delle nuove funzionalità e inviala come pull request. * Mi scuso per il mio inglese approssimativo. Sono benvenuti miglioramenti a questo documento, anche semplici correzioni di refusi. * Se hai grandi idee, invia un'email a [email protected]. **Nota: Preferiamo che tu dia il tuo consiglio nelle [issues](https://github.com/fatedier/frp/issues), così altri con la stessa domanda possono cercarlo rapidamente e non dobbiamo rispondere ripetutamente.** ## Donazioni Se frp ti è stato di grande aiuto, puoi supportarci tramite: ### GitHub Sponsors Supportaci tramite [Github Sponsors](https://github.com/sponsors/fatedier). Puoi far posizionare il logo della tua azienda nel file README di questo progetto. ### PayPal Dona denaro tramite [PayPal](https://www.paypal.me/fatedier) al mio account **[email protected]**.

frp

Più Popolari

Recall.ai - API per registrazioni di riunioni

Cos'è frp?

Indice dei contenuti

Stato di sviluppo

Informazioni su V2

Architettura

Esempio di utilizzo

Accedi al tuo computer in una rete LAN tramite SSH

frps.toml

Più servizi SSH che condividono la stessa porta

frpc.toml

frpc.toml

Esporre un semplice server HTTP per file

frpc.toml

Esponi il tuo servizio privatamente

frpc.toml

Modalità P2P

frpc.toml

set up a new stun server if the default one is not available.

natHoleStunServer = "xxx"

Funzionalità

File di Configurazione

Utilizzo delle Variabili d'Ambiente

frpc.toml

Suddividere le Configurazioni in File Diversi

frpc.toml

🛠️ Caratteristiche