> ## Documentation Index
> Fetch the complete documentation index at: https://help.decodo.com/llms.txt
> Use this file to discover all available pages before exploring further.

# 协议

> 住宅代理支持HTTP、HTTPS和SOCKS5格式

连接协议（`HTTP`、`HTTPS`或`SOCKS5`）可以在您用于连接代理的工具或程序中指定。

在以下`cURL`示例中，协议在代理行的开头指定，只需将`username`和`password`替换为您的代理用户凭据，然后在终端或命令提示符中运行它们。

## HTTP

以下是`HTTP`协议的`cURL`示例：

<CodeGroup>
  ```shellscript cURL theme={null}
  curl -x "http://username:password@gate.decodo.com:7000" "https://ip.decodo.com/json"
  ```
</CodeGroup>

## HTTPS

使用此协议将**加密**您的连接。以下是`HTTPS`协议的`cURL`示例：

<CodeGroup>
  ```shellscript cURL theme={null}
  curl -x "https://username:password@gate.decodo.com:7000" "https://ip.decodo.com/json"
  ```
</CodeGroup>

## SOCKS5

以下是`SOCKS5`协议的`cURL`命令：

<CodeGroup>
  ```shellscript cURL theme={null}
  curl -x "socks5h://user-username-session-1:password@gate.decodo.com:7000" "https://ip.decodo.com/json"
  ```
</CodeGroup>

<Note>
  `socks5h://`中的字母`h`表示主机名将在代理端解析，而不是在本地解析。
</Note>

<Warning>
  ### 国家端点支持

  请注意，您必须使用`gate.decodo.com`端点才能使用`SOCKS5`。像`us.decodo.com`这样的国家端点将无法工作！

  您可以通过使用[**高级参数**](https://help.decodo.com/docs/cn/residential-proxy-advanced-parameters#/)指定位置来定位特定位置。例如，此`cURL`命令定位美国位置：

  ```shellscript theme={null}
  curl -U "user-username-country-us:password" -x "socks5h://gate.decodo.com:7000" "https://ip.decodo.com/json"
  ```
</Warning>

<Warning>
  ### 工具支持

  * 要在**工具**中获取粘性`SOCKS5`代理，您必须使用`session`参数，否则即使使用`sessionduration`参数，代理也会始终轮换。
  * **会话ID**可以由您选择的任何字符串定义。更多信息可以在[**高级参数**](https://help.decodo.com/docs/cn/residential-proxy-advanced-parameters)页面的**粘性会话**部分找到。
</Warning>

## HTTP/3

`HTTP/3`协议运行在通过`SOCKS5`隧道传输的QUIC（UDP）流量之上。`HTTP/3`不支持`HTTP`和`HTTPS`端点。

请使用`socks5-gate.decodo.com`端点的`10000`端口来使用`HTTP/3`，只需将`username`和`password`替换为从您控制台复制的代理用户凭据。

以下是一个`Go`脚本，它通过代理执行`HTTP/3`请求：

<CodeGroup>
  ```go Go expandable theme={null}
  mkdir -p ~/http3-test && cd ~/http3-test
   
  cat > main.go <<'EOF'
  package main
   
  import (
      "bytes"
      "context"
      "crypto/tls"
      "flag"
      "fmt"
      "io"
      "log/slog"
      "net"
      "net/http"
      "time"
   
      "github.com/quic-go/quic-go"
      "github.com/quic-go/quic-go/http3"
      "github.com/txthinking/socks5"
  )
   
  var (
      proxyUsername = flag.String("u", "", "proxy username")
      proxyPassword = flag.String("p", "", "proxy password")
      proxyHost     = flag.String("h", "socks5-gate.decodo.com:10000", "proxy host with port")
      remoteHost    = flag.String("t", "udp-test.decodo.com", "target host")
      payload       = flag.String("body", "", "optional request body")
  )
   
  type SOCKS5PacketConn struct {
      net.Conn
      targetAddr net.Addr
  }
   
  func (s *SOCKS5PacketConn) ReadFrom(p []byte) (int, net.Addr, error) {
      n, err := s.Conn.Read(p)
      return n, s.targetAddr, err
  }
  func (s *SOCKS5PacketConn) WriteTo(p []byte, addr net.Addr) (int, error) {
      return s.Conn.Write(p)
  }
  func (s *SOCKS5PacketConn) LocalAddr() net.Addr { return s.Conn.LocalAddr() }
  func (s *SOCKS5PacketConn) SetDeadline(t time.Time) error { return s.Conn.SetDeadline(t) }
  func (s *SOCKS5PacketConn) SetReadBuffer(bytes int) error {
      if udpConn, ok := s.Conn.(interface{ SetReadBuffer(int) error }); ok {
          return udpConn.SetReadBuffer(bytes)
      }
      return nil
  }
  func (s *SOCKS5PacketConn) SetWriteBuffer(bytes int) error {
      if udpConn, ok := s.Conn.(interface{ SetReadBuffer(int) error }); ok {
          return udpConn.SetReadBuffer(bytes)
      }
      return nil
  }
   
  func HTTP3viaProxy(proxyUsername, proxyPassword, proxyHost, target, payload string) error {
      socks5Client, err := socks5.NewClient(proxyHost, proxyUsername, proxyPassword, 5, 5)
      if err != nil {
          return err
      }
      closeChan := make(chan struct{})
      defer func() { closeChan <- struct{}{} }()
      client := http.Client{
          Transport: &http3.Transport{
              Dial:            proxyDialer(closeChan, socks5Client),
              TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
          },
      }
      req, err := http.NewRequest(http.MethodGet, "https://"+target, bytes.NewReader([]byte(payload)))
      if err != nil {
          return err
      }
      resp, err := client.Do(req)
      if err != nil {
          return err
      }
      defer resp.Body.Close()
      res, err := io.ReadAll(resp.Body)
      if err != nil {
          return err
      }
      fmt.Println("Status: ", resp.StatusCode)
      fmt.Println("Protocol: ", resp.Proto)
      fmt.Printf("Response: \n%s", string(res))
      return nil
  }
   
  func proxyDialer(closeChan <-chan struct{}, socks5client *socks5.Client) func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error) {
      return func(ctx context.Context, addr string, tlsCfg *tls.Config, cfg *quic.Config) (*quic.Conn, error) {
          proxyConn, err := socks5client.Dial("udp", addr)
          if err != nil {
              return nil, err
          }
          go func() {
              <-closeChan
              if proxyConn != nil {
                  if err := proxyConn.Close(); err != nil {
                      slog.Error("Failed to close proxy connection", "error", err)
                  }
              }
          }()
          remoteAddr, err := net.ResolveUDPAddr("udp", addr)
          if err != nil {
              return nil, err
          }
          socks5PacketConn := &SOCKS5PacketConn{Conn: proxyConn, targetAddr: remoteAddr}
          deadline := time.Now().Add(40 * time.Second)
          if err = proxyConn.SetReadDeadline(deadline); err != nil {
              return nil, err
          }
          if err = proxyConn.SetWriteDeadline(deadline); err != nil {
              return nil, err
          }
          earlyConn, err := quic.DialEarly(ctx, socks5PacketConn, remoteAddr, tlsCfg, cfg)
          if err != nil {
              return nil, err
          }
          return earlyConn, nil
      }
  }
   
  func main() {
      flag.Parse()
      start := time.Now()
      if err := HTTP3viaProxy(*proxyUsername, *proxyPassword, *proxyHost, *remoteHost, *payload); err != nil {
          slog.Error("failed to perform HTTP3 request via proxy", "error", err)
      }
      fmt.Printf("Request took: %d ms\n", time.Since(start).Milliseconds())
  }
  EOF
   
  go mod init http3-test
  go get github.com/quic-go/quic-go github.com/quic-go/quic-go/http3 github.com/txthinking/socks5
  go run main.go
  ```
</CodeGroup>

***

## 端口

轻松了解使用我们的代理时可以访问哪些端口，包括默认可访问端口的详细信息、限制以及如何请求解除端口封锁。

### 可访问端口

使用**住宅**和**移动**代理时，默认情况下可以访问以下端口：

* `80`
* `443`

### 受限端口

<Warning>
  受限端口包括\*\*`SMTP`**、**`IMAP`**和其他**邮件**和**消息\*\*相关端口。
</Warning>

### 端口解封流程

要请求解除端口封锁，请通过[**compliance@decodo.com**](mailto:compliance@decodo.com)联系我们并提供以下信息：

* 需要解除封锁的**端口**。
* 描述该端口的**使用场景** - **尽可能具体**。
* 提供您将使用所述端口访问的**目标**。

为了增加安全性，特别是对于涉及敏感或高风险端口的请求，我们将要求用户提供**公司详细信息**或完成身份验证以完成解封请求。

<Note>
  请注意，某些端口（例如被归类为受限的端口）无法解除封锁。虽然本文未提及具体端口，但您解除封锁的请求可能会被拒绝。
</Note>

***

<Columns cols={2}>
  <Card title="支持" href="https://direct.lc.chat/12092754" cta="让我们聊聊！">
    需要帮助或只是想打个招呼？我们的支持团队全天候为您服务。 \
    您也可以随时通过电子邮件 [support@decodo.com](mailto:support@decodo.com) 联系我们。
  </Card>

  <Card title="反馈" href="mailto:feedback@decodo.com" cta="分享反馈">
    找不到您要找的内容？请求一篇文章！ \
    有反馈意见？分享您对我们如何改进的想法。
  </Card>
</Columns>