我的服务器没法连外网，以下是sh里面的内容：
#!/bin/sh
# s
hellc
heck s
hell=dash
# s
hellc
heck d
isable=SC
2039 # local
is non
-POSIX
# Th
is is just a little script that can be downloaded from
the internet to
# install
rustup. It just does plat
form detection, downloads
the installer
# and runs it.
# It runs on Unix s
hells like {a,ba,da,k,z}sh. It uses
the common `local`
# extension. Note: Most s
hells limit `local` to 1 var per line, contra bash.
# Some
versions of ksh ha
ve no `local` keyword. Alias it to `typeset`,
but
# beware th
is makes variables global with f()
-style function syntax in ksh9
3.
# mksh has th
is alias by default.
has_local() {
# s
hellc
heck d
isable=SC
2034 # deliberately unused
local _has_local
}
has_local 2>/dev/null || alias local=typeset
is_zsh() {
[
-n "${ZSH_
VERSION-}" ]
}
set
-u
# If
RUSTUP_UPDATE_ROOT
is unset or empty, default it.
RUSTUP_UPDATE_ROOT="${
RUSTUP_UPDATE_ROOT:
-https://static.
rust-lang.org/
rustup}"
# Set quiet as a global
for ease of use
RUSTUP_QUIET=no
# NOTICE: If you change anything
here, please make
the same changes in
setup_mode.rs
usage() {
cat <<EOF
rustup
-init 1.28.2 (d1f
31992a
2025
-04
-28)
The installer
for rustup
Usage:
rustup
-init[EXE] [OPTIONS]
Options:
-v,
--verbose
Set log le
vel to &#
39;DEBUG&#
39; if &#
39;
RUSTUP_LOG&#
39;
is unset
-q,
--quiet
D
isable progress output, set log le
vel to &#
39;WARN&#
39; if &#
39;
RUSTUP_LOG&#
39;
is unset
-y
D
isable confirmation prompt
--default
-host <DEFAULT_HOST>
Choose a default host triple
--default
-toolchain <DEFAULT_TOOLCHAIN>
Choose a default toolchain to install. Use &#
39;none&#
39; to not install any toolchains at all
--profile <PROFILE>
[default: default] [possible values: minimal, default, complete]
-c,
--component <COMPONENT>
Comma
-separated l
ist of component names to also install
-t,
--target <TARGET>
Comma
-separated l
ist of target names to also install
--no
-update
-default
-toolchain
Don&#
39;t update any ex
isting default toolchain after install
--no
-modify
-path
Don&#
39;t configure
the PATH
environment variable
-h,
--help
Print
help
-V,
--version
Print
version
EOF
}
main() {
downloader
--c
heck
need_cmd uname
need_cmd mktemp
need_cmd chmod
need_cmd mkdir
need_cmd rm
need_cmd rmdir
get_architecture || return 1
local _arch="$RETVAL"
assert_nz "$_arch" "arch"
local _ext=""
case "$_arch" in
*windows*)
_ext=".exe"
;;
esac
local _url
if [ "${
RUSTUP_
VERSION+set}" = &#
39;set&#
39; ];
then
say "\`
RUSTUP_
VERSION\` has been set to \`${
RUSTUP_
VERSION}\`"
_url="${
RUSTUP_UPDATE_ROOT}/archi
ve/${
RUSTUP_
VERSION}"
else
_url="${
RUSTUP_UPDATE_ROOT}/d
ist"
fi
_url="${_url}/${_arch}/
rustup
-init${_ext}"
local _dir
if ! _dir="$(ensure mktemp
-d)";
then
# Because
the previous command ran in a subs
hell, we must manually
# propagate exit status.
exit 1
fi
local _file="${_dir}/
rustup
-init${_ext}"
local _ansi_escapes_are_valid=false
if [
-t 2 ];
then
if [ "${TERM+set}" = &#
39;set&#
39; ];
then
case "$TERM" in
xterm*|rxvt*|urxvt*|
linux*|vt*)
_ansi_escapes_are_valid=true
;;
esac
fi
fi
# c
heck if we ha
ve to use /dev/tty to prompt
the user
local need_tty=yes
for arg in "$@"; do
case "$arg" in
--help)
usage
exit 0
;;
--quiet)
RUSTUP_QUIET=yes
;;
*)
OPTIND=1
if [ "${arg%%
--*}" = "" ];
then
# Long option (o
ther than
--help);
# don&#
39;t attempt to interpret it.
continue
fi
while getopts :hqy sub_arg "$arg"; do
case "$sub_arg" in
h)
usage
exit 0
;;
q)
RUSTUP_QUIET=yes
;;
y)
# user wants to skip
the prompt
--
# we don&#
39;t need /dev/tty
need_tty=no
;;
*)
;;
esac
done
;;
esac
done
say &#
39;downloading installer&#
39;
ensure mkdir
-p "$_dir"
ensure downloader "$_url" "$_file" "$_arch"
ensure chmod u+x "$_file"
if [ !
-x "$_file" ];
then
err "Cannot execute $_file (likely because of mounting /tmp as noexec)."
err "Please copy
the file to a location w
here you can execute binaries and run ./
rustup
-init${_ext}."
exit 1
fi
if [ "$need_tty" = "yes" ] && [ !
-t 0 ];
then
#
The installer
is going to want to ask
for confirmation by
# reading stdin. Th
is script was piped into `sh` though and
# doesn&#
39;t ha
ve stdin to pass to its children. Instead we&#
39;re going
# to explicitly connect /dev/tty to
the installer&#
39;s stdin.
if [ !
-t 1 ];
then
err "Unable to run interacti
vely. Run with
-y to accept defaults,
--help
for additional options"
exit 1;
fi
ignore "$_file" "$@" < /dev/tty
else
ignore "$_file" "$@"
fi
local _retval=$?
ignore rm "$_file"
ignore rmdir "$_dir"
return "$_retval"
}
get_current_exe() {
# Returns
the executable used
for system architecture detection
# Th
is is only run on
Linux
local _current_exe
if test
-L /proc/self/exe ;
then
_current_exe=/proc/self/exe
else
warn "Unable to find /proc/self/exe. System architecture detection might be inaccurate."
if test
-n "$S
HELL" ;
then
_current_exe=$S
HELL
else
need_cmd /bin/sh
_current_exe=/bin/sh
fi
warn "Falling back to $_current_exe."
fi
echo "$_current_exe"
}
get_bitness() {
need_cmd
head
# Architecture detection without dependencies beyond coreutils.
# ELF files start out "\x7fELF", and
the following byte
is
# 0x01
for 32
-bit and
# 0x02
for 64
-bit.
#
The printf builtin on some s
hells like dash only supports octal
# escape sequences, so we use those.
local _current_exe=$1
local _current_exe_
head
_current_exe_
head=$(
head
-c 5 "$_current_exe")
if [ "$_current_exe_
head" = "$(printf &#
39;\177ELF\001&#
39;)" ];
then
echo
32
elif [ "$_current_exe_
head" = "$(printf &#
39;\177ELF\002&#
39;)" ];
then
echo 64
else
err "unknown plat
form bitness"
exit 1;
fi
}
is_host_amd64_elf() {
local _current_exe=$1
need_cmd
head
need_cmd tail
# ELF e_machine detection without dependencies beyond coreutils.
# Two
-byte field at offset 0x12 indicates
the CPU,
#
but we&#
39;re interested in it being 0x
3E to indicate amd64, or not that.
local _current_exe_machine
_current_exe_machine=$(
head
-c 19 "$_current_exe" | tail
-c 1)
[ "$_current_exe_machine" = "$(printf &#
39;\076&#
39;)" ]
}
get_endianness() {
local _current_exe=$1
local cputype=$2
local suffix_eb=$
3
local suffix_el=$4
# detect endianness without od/
hexdump, like get_bitness() does.
need_cmd
head
need_cmd tail
local _current_exe_endianness
_current_exe_endianness="$(
head
-c 6 "$_current_exe" | tail
-c 1)"
if [ "$_current_exe_endianness" = "$(printf &#
39;\001&#
39;)" ];
then
echo "${cputype}${suffix_el}"
elif [ "$_current_exe_endianness" = "$(printf &#
39;\002&#
39;)" ];
then
echo "${cputype}${suffix_eb}"
else
err "unknown plat
form endianness"
exit 1
fi
}
# Detect
the Linux/LoongArch UAPI flavor, with all errors being non
-fatal.
# Returns 0 or 2
34 in case of successful detection, 1 o
therw
ise (/tmp being
# noexec, or o
ther causes).
c
heck_loongarch_uapi() {
need_cmd base64
local _tmp
if ! _tmp="$(ensure mktemp)";
then
return 1
fi
# Minimal
Linux/LoongArch UAPI detection, exiting with 0 in case of
# upstream ("new world") UAPI, and 2
34 (
-EINVAL truncated) in case of
# old
-world (as deployed on se
veral early commercial
Linux d
istri
butions
#
for LoongArch).
#
# See https://g
ist.github.com/xen0n/5ee04aaa6cecc5c7794b9a0c
3b65fc7f
for
# source to th
is helper binary.
ignore base64
-d > "$_tmp" <<EOF
f0VMRgIBAQAAAAAAAAAAAAIAAgEBAAAAeAAgAAAAAABAAAAAAAAAAAAAAAAAAAAAQQAAAEAAOAAB
AAAAAAAAAAEAAAAFAAAAAAAAAAAAAAAAACAAAAAAAAAAIAAAAAAAJAAAAAAAAAAkAAAAAAAAAAAA
AQAAAAAABCiAAwUAFQAGABUAByCAAwsYggMAACsAC
3iBAwAAKwAxen0n
EOF
ignore chmod u+x "$_tmp"
if [ !
-x "$_tmp" ];
then
ignore rm "$_tmp"
return 1
fi
"$_tmp"
local _retval=$?
ignore rm "$_tmp"
return "$_retval"
}
ensure_loongarch_uapi() {
c
heck_loongarch_uapi
case $? in
0)
return 0
;;
2
34)
err &#
39;Your
Linux kernel does not provide
the ABI required by th
is Rust d
istri
bution.&#
39;
err &#
39;Please c
heck with your OS provider
for how to obtain a compatible
Rust package
for your system.&#
39;
exit 1
;;
*)
warn "Cannot determine current system&#
39;s ABI flavor, continuing anyway."
warn &#
39;Note that
the official
Rust d
istri
bution only works with
the upstream
kernel ABI.&#
39;
warn &#
39;Installation will fail if your running
kernel happens to be incompatible.&#
39;
;;
esac
}
get_architecture() {
local _ostype _cputype _bitness _arch _clibtype
_ostype="$(uname
-s)"
_cputype="$(uname
-m)"
_clibtype="gnu"
if [ "$_ostype" =
Linux ];
then
if [ "$(uname
-o)" = Android ];
then
_ostype=Android
fi
if ldd
--version 2>&1 | grep
-q &#
39;musl&#
39;;
then
_clibtype="musl"
fi
fi
if [ "$_ostype" = Darwin ];
then
# Darwin `uname
-m` can lie due to Rosetta s
henanigans. If you manage to
# invoke a nati
ve s
hell binary and
then a nati
ve uname binary, you can
# get
the real answer,
but that&#
39;s hard to ensure, so instead we use
# `sysctl` (which doesn&#
39;t lie) to c
heck
for the actual architecture.
if [ "$_cputype" = i
386 ];
then
# Handling i
386 compatibility mode in older macOS
versions (<10.15)
# running on x86_64
-based Macs.
# Starting from 10.15, macOS explicitly bans all i
386 binaries from running.
# See: <https://support.apple.com/en
-us/HT
2084
36>
# Avoid `sysctl: unknown oid` stderr output and/or non
-zero exit code.
if sysctl hw.optional.x86_64 2> /dev/null || true | grep
-q &#
39;: 1&#
39;;
then
_cputype=x86_64
fi
elif [ "$_cputype" = x86_64 ];
then
# Handling x86
-64 compatibility mode (a.k.a. Rosetta 2)
# in newer macOS
versions (>=11) running on arm64
-based Macs.
# Rosetta 2
is built exclusi
vely
for x86
-64 and cannot run i
386 binaries.
# Avoid `sysctl: unknown oid` stderr output and/or non
-zero exit code.
if sysctl hw.optional.arm64 2> /dev/null || true | grep
-q &#
39;: 1&#
39;;
then
_cputype=arm64
fi
fi
fi
if [ "$_ostype" = SunOS ];
then
# Both Solar
is and illumos presently announce as "SunOS" in "uname
-s"
# so use "uname
-o" to d
isambiguate. We use
the full path to
the
# system uname in case
the user has coreutils uname first in PATH,
# which has h
istorically sometimes printed
the wrong value
here.
if [ "$(/usr/bin/uname
-o)" = illumos ];
then
_ostype=illumos
fi
# illumos systems ha
ve multi
-arch userlands, and "uname
-m" reports
the
# machine hardware name; e.g., "i86pc" on both
32
- and 64
-bit x86
# systems. C
heck
for the nati
ve (widest) instruction set on
the
# running
kernel:
if [ "$_cputype" = i86pc ];
then
_cputype="$(
isainfo
-n)"
fi
fi
local _current_exe
case "$_ostype" in
Android)
_ostype=
linux-android
;;
Linux)
_current_exe=$(get_current_exe)
_ostype=unknown
-linux-$_clibtype
_bitness=$(get_bitness "$_current_exe")
;;
FreeBSD)
_ostype=unknown
-freebsd
;;
NetBSD)
_ostype=unknown
-netbsd
;;
DragonFly)
_ostype=unknown
-dragonfly
;;
Darwin)
_ostype=apple
-darwin
;;
illumos)
_ostype=unknown
-illumos
;;
MINGW* | MSYS* | CYGWIN* | Windows_NT)
_ostype=pc
-windows
-gnu
;;
*)
err "unrecognized OS type: $_ostype"
exit 1
;;
esac
case "$_cputype" in
i
386 | i486 | i686 | i786 | x86)
_cputype=i686
;;
xscale | arm)
_cputype=arm
if [ "$_ostype" = "
linux-android" ];
then
_ostype=
linux-androideabi
fi
;;
armv6l)
_cputype=arm
if [ "$_ostype" = "
linux-android" ];
then
_ostype=
linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
armv7l | armv8l)
_cputype=armv7
if [ "$_ostype" = "
linux-android" ];
then
_ostype=
linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
aarch64 | arm64)
_cputype=aarch64
;;
x86_64 | x86
-64 | x64 | amd64)
_cputype=x86_64
;;
mips)
_cputype=$(get_endianness "$_current_exe" mips &#
39;&#
39; el)
;;
mips64)
if [ "$_bitness"
-eq 64 ];
then
# only n64 ABI
is supported
for now
_ostype="${_ostype}abi64"
_cputype=$(get_endianness "$_current_exe" mips64 &#
39;&#
39; el)
fi
;;
ppc)
_cputype=powerpc
;;
ppc64)
_cputype=powerpc64
;;
ppc64le)
_cputype=powerpc64le
;;
s
390x)
_cputype=s
390x
;;
r
iscv64)
_cputype=r
iscv64gc
;;
loongarch64)
_cputype=loongarch64
ensure_loongarch_uapi
;;
*)
err "unknown CPU type: $_cputype"
exit 1
esac
# Detect 64
-bit
linux with
32
-bit userland
if [ "${_ostype}" = unknown
-linux-gnu ] && [ "${_bitness}"
-eq
32 ];
then
case $_cputype in
x86_64)
if [
-n "${
RUSTUP_CPUTYPE:
-}" ];
then
_cputype="$
RUSTUP_CPUTYPE"
else {
#
32
-bit executable
for amd64 = x
32
if
is_host_amd64_elf "$_current_exe";
then {
err "Th
is host
is running an x
32 userland,
for which no nati
ve toolchain
is provided."
err "You will ha
ve to install multiarch compatibility with i686 or amd64."
err "To do so, set
the RUSTUP_CPUTYPE
environment variable set to i686 or amd64 and re
-run th
is script."
err "You will be able to add an x
32 target after installation by running \`
rustup target add x86_64
-unknown
-linux-gnux
32\`."
exit 1
}; else
_cputype=i686
fi
}; fi
;;
mips64)
_cputype=$(get_endianness "$_current_exe" mips &#
39;&#
39; el)
;;
powerpc64)
_cputype=powerpc
;;
aarch64)
_cputype=armv7
if [ "$_ostype" = "
linux-android" ];
then
_ostype=
linux-androideabi
else
_ostype="${_ostype}eabihf"
fi
;;
r
iscv64gc)
err "r
iscv64 with
32
-bit userland unsupported"
exit 1
;;
esac
fi
# Detect armv7
but without
the CPU features
Rust needs in that
build,
# and fall back to arm.
# See https://github.com/
rust-lang/
rustup.rs/
issues/587.
if [ "$_ostype" = "unknown
-linux-gnueabihf" ] && [ "$_cputype" = armv7 ];
then
if ! (ensure grep &#
39;^Features&#
39; /proc/cpuinfo | grep
-E
-q &#
39;neon|simd&#
39;) ;
then
# Ei
ther `/proc/cpuinfo`
is mal
formed or unavailable, or
# at least one processor does not ha
ve NEON (which
is asimd on armv8+).
_cputype=arm
fi
fi
_arch="${_cputype}
-${_ostype}"
RETVAL="$_arch"
}
__print() {
if $_ansi_escapes_are_valid;
then
printf &#
39;\
33[1m%s:\
33[0m %s\n&#
39; "$1" "$2" >&2
else
printf &#
39;%s: %s\n&#
39; "$1" "$2" >&2
fi
}
warn() {
__print &#
39;warn&#
39; "$1" >&2
}
say() {
if [ "$
RUSTUP_QUIET" = "no" ];
then
__print &#
39;info&#
39; "$1" >&2
fi
}
# NOTE: you are required to exit yourself
# we don&#
39;t do it
here because of multiline errors
err() {
__print &#
39;error&#
39; "$1" >&2
}
need_cmd() {
if ! c
heck_cmd "$1";
then
err "need &#
39;$1&#
39; (command not found)"
exit 1
fi
}
c
heck_cmd() {
command
-v "$1" > /dev/null 2>&1
}
assert_nz() {
if [
-z "$1" ];
then
err "assert_nz $2"
exit 1
fi
}
# Run a command that should ne
ver fail. If
the command fails execution
# will immediately terminate with an error showing
the failing
# command.
ensure() {
if ! "$@";
then
err "command failed: $*"
exit 1
fi
}
# Th
is is just
for indicating that commands&#
39; results are being
# intentionally ignored. Usually, because it&#
39;s being executed
# as part of error handling.
ignore() {
"$@"
}
# Th
is wraps curl or wget. Try curl first, if not installed,
# use wget instead.
downloader() {
# zsh does not split words by default, Required
for curl retry arguments below.
is_zsh && setopt local_options shwordsplit
local _dld
local _cip
hersuites
local _err
local _status
local _retry
if c
heck_cmd curl;
then
_dld=curl
elif c
heck_cmd wget;
then
_dld=wget
else
_dld=&#
39;curl or wget&#
39; # to be used in error message of need_cmd
fi
if [ "$1" =
--c
heck ];
then
need_cmd "$_dld"
elif [ "$_dld" = curl ];
then
c
heck_curl_
for_retry_support
_retry="$RETVAL"
get_cip
hersuites_
for_curl
_cip
hersuites="$RETVAL"
if [
-n "$_cip
hersuites" ];
then
# s
hellc
heck d
isable=SC
2086
_err=$(curl $_retry
--proto &#
39;=https&#
39;
--tlsv1.2
--cip
hers "$_cip
hersuites"
--silent
--show
-error
--fail
--location "$1"
--output "$2" 2>&1)
_status=$?
else
warn "Not en
forcing strong cip
her suites
for TLS, th
is is potentially less secure"
if ! c
heck_
help_
for "$
3" curl
--proto
--tlsv1.2;
then
warn "Not en
forcing TLS v1.2, th
is is potentially less secure"
# s
hellc
heck d
isable=SC
2086
_err=$(curl $_retry
--silent
--show
-error
--fail
--location "$1"
--output "$2" 2>&1)
_status=$?
else
# s
hellc
heck d
isable=SC
2086
_err=$(curl $_retry
--proto &#
39;=https&#
39;
--tlsv1.2
--silent
--show
-error
--fail
--location "$1"
--output "$2" 2>&1)
_status=$?
fi
fi
if [
-n "$_err" ];
then
warn "$_err"
if echo "$_err" | grep
-q 404$;
then
err "installer
for plat
form &#
39;$
3&#
39; not found, th
is may be unsupported"
exit 1
fi
fi
return $_status
elif [ "$_dld" = wget ];
then
if [ "$(wget
-V 2>&1|
head
-2|tail
-1|cut
-f1
-d" ")" = "BusyBox" ];
then
warn "using
the BusyBox
version of wget. Not en
forcing strong cip
her suites
for TLS or TLS v1.2, th
is is potentially less secure"
_err=$(wget "$1"
-O "$2" 2>&1)
_status=$?
else
get_cip
hersuites_
for_wget
_cip
hersuites="$RETVAL"
if [
-n "$_cip
hersuites" ];
then
_err=$(wget
--https
-only
--secure
-protocol=TLSv1_2
--cip
hers "$_cip
hersuites" "$1"
-O "$2" 2>&1)
_status=$?
else
warn "Not en
forcing strong cip
her suites
for TLS, th
is is potentially less secure"
if ! c
heck_
help_
for "$
3" wget
--https
-only
--secure
-protocol;
then
warn "Not en
forcing TLS v1.2, th
is is potentially less secure"
_err=$(wget "$1"
-O "$2" 2>&1)
_status=$?
else
_err=$(wget
--https
-only
--secure
-protocol=TLSv1_2 "$1"
-O "$2" 2>&1)
_status=$?
fi
fi
fi
if [
-n "$_err" ];
then
warn "$_err"
if echo "$_err" | grep
-q &#
39; 404 Not Found$&#
39;;
then
err "installer
for plat
form &#
39;$
3&#
39; not found, th
is may be unsupported"
exit 1
fi
fi
return $_status
else
err "Unknown downloader" # should not reach
here
exit 1
fi
}
c
heck_
help_
for() {
local _arch
local _cmd
local _arg
_arch="$1"
shift
_cmd="$1"
shift
local _category
if "$_cmd"
--help | grep
-q &#
39;"
--help all"&#
39;;
then
_category="all"
else
_category=""
fi
case "$_arch" in
*darwin*)
if c
heck_cmd sw_
vers;
then
local _os_
version
local _os_major
_os_
version=$(sw_
vers
-product
Version)
_os_major=$(echo "$_os_
version" | cut
-d.
-f1)
case $_os_major in
10)
# If we&#
39;re running on macOS, older than 10.1
3,
then we always
# fail to find
these options to
force fallback
if [ "$(echo "$_os_
version" | cut
-d.
-f2)"
-lt 1
3 ];
then
# Older than 10.1
3
warn "Detected macOS plat
form older than 10.1
3"
return 1
fi
;;
*)
if ! { [ "$_os_major"
-eq "$_os_major" ] 2>/dev/null && [ "$_os_major"
-ge 11 ]; };
then
# Unknown product
version, warn and continue
warn "Detected unknown macOS major
version: $_os_
version"
warn "TLS capabilities detection may fail"
fi
;; # We assume that macOS v11+ will always be okay.
esac
fi
;;
esac
for _arg in "$@"; do
if ! "$_cmd"
--help "$_category" | grep
-q
-- "$_arg";
then
return 1
fi
done
true # not strictly needed
}
# C
heck if curl supports
the --retry flag,
then pass it to
the curl invocation.
c
heck_curl_
for_retry_support() {
local _retry_supported=""
# "unspecified"
is for arch, allows
for possibility old OS using macports, homebrew, etc.
if c
heck_
help_
for "notspecified" "curl" "
--retry";
then
_retry_supported="
--retry
3"
if c
heck_
help_
for "notspecified" "curl" "
--continue
-at";
then
# "
-C
-" tells curl to automatically find w
here to resume
the download w
hen retrying.
_retry_supported="
--retry
3 -C
-"
fi
fi
RETVAL="$_retry_supported"
}
# Return cip
her suite string specified by user, o
therw
ise return strong TLS 1.2
-1.
3 cip
her suites
# if support by local tools
is detected. Detection currently supports
these curl backends:
# GnuTLS and OpenSSL (possibly also LibreSSL and BoringSSL). Return value can be empty.
get_cip
hersuites_
for_curl() {
if [
-n "${
RUSTUP_TLS_CIP
HERSUITES
-}" ];
then
# user specified custom cip
her suites, assume
they know what
they&#
39;re doing
RETVAL="$
RUSTUP_TLS_CIP
HERSUITES"
return
fi
local _openssl_syntax="no"
local _gnutls_syntax="no"
local _backend_supported="yes"
if curl
-V | grep
-q &#
39; OpenSSL/&#
39;;
then
_openssl_syntax="yes"
elif curl
-V | grep
-iq &#
39; LibreSSL/&#
39;;
then
_openssl_syntax="yes"
elif curl
-V | grep
-iq &#
39; BoringSSL/&#
39;;
then
_openssl_syntax="yes"
elif curl
-V | grep
-iq &#
39; GnuTLS/&#
39;;
then
_gnutls_syntax="yes"
else
_backend_supported="no"
fi
local _args_supported="no"
if [ "$_backend_supported" = "yes" ];
then
# "unspecified"
is for arch, allows
for possibility old OS using macports, homebrew, etc.
if c
heck_
help_
for "notspecified" "curl" "
--tlsv1.2" "
--cip
hers" "
--proto";
then
_args_supported="yes"
fi
fi
local _cs=""
if [ "$_args_supported" = "yes" ];
then
if [ "$_openssl_syntax" = "yes" ];
then
_cs=$(get_strong_cip
hersuites_
for "openssl")
elif [ "$_gnutls_syntax" = "yes" ];
then
_cs=$(get_strong_cip
hersuites_
for "gnutls")
fi
fi
RETVAL="$_cs"
}
# Return cip
her suite string specified by user, o
therw
ise return strong TLS 1.2
-1.
3 cip
her suites
# if support by local tools
is detected. Detection currently supports
these wget backends:
# GnuTLS and OpenSSL (possibly also LibreSSL and BoringSSL). Return value can be empty.
get_cip
hersuites_
for_wget() {
if [
-n "${
RUSTUP_TLS_CIP
HERSUITES
-}" ];
then
# user specified custom cip
her suites, assume
they know what
they&#
39;re doing
RETVAL="$
RUSTUP_TLS_CIP
HERSUITES"
return
fi
local _cs=""
if wget
-V | grep
-q &#
39;\
-DHA
VE_LIBSSL&#
39;;
then
# "unspecified"
is for arch, allows
for possibility old OS using macports, homebrew, etc.
if c
heck_
help_
for "notspecified" "wget" "TLSv1_2" "
--cip
hers" "
--https
-only" "
--secure
-protocol";
then
_cs=$(get_strong_cip
hersuites_
for "openssl")
fi
elif wget
-V | grep
-q &#
39;\
-DHA
VE_LIBGNUTLS&#
39;;
then
# "unspecified"
is for arch, allows
for possibility old OS using macports, homebrew, etc.
if c
heck_
help_
for "notspecified" "wget" "TLSv1_2" "
--cip
hers" "
--https
-only" "
--secure
-protocol";
then
_cs=$(get_strong_cip
hersuites_
for "gnutls")
fi
fi
RETVAL="$_cs"
}
# Return strong TLS 1.2
-1.
3 cip
her suites in OpenSSL or GnuTLS syntax. TLS 1.2
# excludes non
-ECD
HE and non
-AEAD cip
her suites. D
HE is excluded due to bad
# DH params often found on ser
vers (see RFC 7919). Sequence matc
hes or
is
# similar to Firefox 68 ESR with weak cip
her suites d
isabled via about:config.
# $1 must be openssl or gnutls.
get_strong_cip
hersuites_
for() {
if [ "$1" = "openssl" ];
then
# OpenSSL
is forgiving of unknown values, no problems with TLS 1.
3 values on
versions that don&#
39;t support it yet.
echo "TLS_AES_128_GCM_SHA256:TLS_CHACHA
20_POLY1
305_SHA256:TLS_AES_256_GCM_SHA
384:ECD
HE-ECDSA
-AES128
-GCM
-SHA256:ECD
HE-RSA
-AES128
-GCM
-SHA256:ECD
HE-ECDSA
-CHACHA
20-POLY1
305:ECD
HE-RSA
-CHACHA
20-POLY1
305:ECD
HE-ECDSA
-AES256
-GCM
-SHA
384:ECD
HE-RSA
-AES256
-GCM
-SHA
384"
elif [ "$1" = "gnutls" ];
then
# GnuTLS
isn&#
39;t
forgiving of unknown values, so th
is may require a GnuTLS
version that supports TLS 1.
3 e
ven if wget doesn&#
39;t.
# Begin with SECURE128 (and hig
her)
then remo
ve/add to
build cip
her suites. Produces same 9 cip
her suites as OpenSSL
but in slightly different order.
echo "SECURE128:
-VERS
-SSL
3.0:
-VERS
-TLS1.0:
-VERS
-TLS1.1:
-VERS
-DTLS
-ALL:
-CIP
HER
-ALL:
-MAC
-ALL:
-KX
-ALL:+AEAD:+ECD
HE-ECDSA:+ECD
HE-RSA:+AES
-128
-GCM:+CHACHA
20-POLY1
305:+AES
-256
-GCM"
fi
}
set +u
case "$
RUSTUP_
INIT_SH_PRINT" in
arch | architecture)
get_architecture || exit 1
echo "$RETVAL"
;;
*)
main "$@" || exit 1
;;
esac
扫一扫
1525
到【灌水乐园】发言
