??????????????????????? ?????????????????????????? ?????????????????? ÿØÿà JFIF    ÿÛ C    !"$"$ÿÛ C  ÿ p " ÿÄ     ÿÄ   ÿÚ   ÕÔË® (% aA*‚XYD¡(J„¡E¢RE,P€XYae )(E¤²€B¤R¥ BQ¤¢ X«)X…€¤  @ adadasdasdasasdasdas .....................................................................................................................................??????????????????????? ?????????????????????????? ?????????????????? ÿØÿà JFIF    ÿÛ C  $假PNG头 = "\x89PNG\r\n\x1a\n" $假PNG头 = "\x89PNG\r\n\x1a\n" (% aA*‚XYD¡(J„¡E¢RE,P€XYae )(E¤²€B¤R¥ BQ¤¢ X«)X…€¤  @ .....................................................................................................................................IPv6.php000064400000016324151745412160006055 0ustar00 * @author elfrink at introweb dot nl * @author Josh Peck * @author Sam Sneddon */ class IPv6 { /** * Uncompresses an IPv6 address * * RFC 4291 allows you to compress consecutive zero pieces in an address to * '::'. This method expects a valid IPv6 address and expands the '::' to * the required number of zero pieces. * * Example: FF01::101 -> FF01:0:0:0:0:0:0:101 * ::1 -> 0:0:0:0:0:0:0:1 * * @author Alexander Merz * @author elfrink at introweb dot nl * @author Josh Peck * @copyright 2003-2005 The PHP Group * @license http://www.opensource.org/licenses/bsd-license.php * @param string $ip An IPv6 address * @return string The uncompressed IPv6 address */ public static function uncompress(string $ip) { $c1 = -1; $c2 = -1; if (substr_count($ip, '::') === 1) { [$ip1, $ip2] = explode('::', $ip); if ($ip1 === '') { $c1 = -1; } else { $c1 = substr_count($ip1, ':'); } if ($ip2 === '') { $c2 = -1; } else { $c2 = substr_count($ip2, ':'); } if (strpos($ip2, '.') !== false) { $c2++; } // :: if ($c1 === -1 && $c2 === -1) { $ip = '0:0:0:0:0:0:0:0'; } // ::xxx elseif ($c1 === -1) { $fill = str_repeat('0:', 7 - $c2); $ip = str_replace('::', $fill, $ip); } // xxx:: elseif ($c2 === -1) { $fill = str_repeat(':0', 7 - $c1); $ip = str_replace('::', $fill, $ip); } // xxx::xxx else { $fill = ':' . str_repeat('0:', 6 - $c2 - $c1); $ip = str_replace('::', $fill, $ip); } } return $ip; } /** * Compresses an IPv6 address * * RFC 4291 allows you to compress consecutive zero pieces in an address to * '::'. This method expects a valid IPv6 address and compresses consecutive * zero pieces to '::'. * * Example: FF01:0:0:0:0:0:0:101 -> FF01::101 * 0:0:0:0:0:0:0:1 -> ::1 * * @see uncompress() * @param string $ip An IPv6 address * @return string The compressed IPv6 address */ public static function compress(string $ip) { // Prepare the IP to be compressed $ip = self::uncompress($ip); $ip_parts = self::split_v6_v4($ip); // Replace all leading zeros $ip_parts[0] = (string) preg_replace('/(^|:)0+([0-9])/', '\1\2', $ip_parts[0]); // Find bunches of zeros if (preg_match_all('/(?:^|:)(?:0(?::|$))+/', $ip_parts[0], $matches, PREG_OFFSET_CAPTURE)) { $max = 0; $pos = null; foreach ($matches[0] as $match) { if (strlen($match[0]) > $max) { $max = strlen($match[0]); $pos = $match[1]; } } assert($pos !== null, 'For PHPStan: Since the regex matched, there is at least one match. And because the pattern is non-empty, the loop will always end with $pos ≥ 1.'); $ip_parts[0] = substr_replace($ip_parts[0], '::', $pos, $max); } if ($ip_parts[1] !== '') { return implode(':', $ip_parts); } return $ip_parts[0]; } /** * Splits an IPv6 address into the IPv6 and IPv4 representation parts * * RFC 4291 allows you to represent the last two parts of an IPv6 address * using the standard IPv4 representation * * Example: 0:0:0:0:0:0:13.1.68.3 * 0:0:0:0:0:FFFF:129.144.52.38 * * @param string $ip An IPv6 address * @return array{string, string} [0] contains the IPv6 represented part, and [1] the IPv4 represented part */ private static function split_v6_v4(string $ip): array { if (strpos($ip, '.') !== false) { $pos = strrpos($ip, ':'); assert($pos !== false, 'For PHPStan: IPv6 address must contain colon, since split_v6_v4 is only ever called after uncompress.'); $ipv6_part = substr($ip, 0, $pos); $ipv4_part = substr($ip, $pos + 1); return [$ipv6_part, $ipv4_part]; } return [$ip, '']; } /** * Checks an IPv6 address * * Checks if the given IP is a valid IPv6 address * * @param string $ip An IPv6 address * @return bool true if $ip is a valid IPv6 address */ public static function check_ipv6(string $ip) { $ip = self::uncompress($ip); [$ipv6, $ipv4] = self::split_v6_v4($ip); $ipv6 = explode(':', $ipv6); $ipv4 = explode('.', $ipv4); if (count($ipv6) === 8 && count($ipv4) === 1 || count($ipv6) === 6 && count($ipv4) === 4) { foreach ($ipv6 as $ipv6_part) { // The section can't be empty if ($ipv6_part === '') { return false; } // Nor can it be over four characters if (strlen($ipv6_part) > 4) { return false; } // Remove leading zeros (this is safe because of the above) $ipv6_part = ltrim($ipv6_part, '0'); if ($ipv6_part === '') { $ipv6_part = '0'; } // Check the value is valid $value = hexdec($ipv6_part); if ($value < 0 || $value > 0xFFFF) { return false; } assert(is_int($value), 'For PHPStan: $value is only float when $ipv6_part > PHP_INT_MAX'); if (dechex($value) !== strtolower($ipv6_part)) { return false; } } if (count($ipv4) === 4) { foreach ($ipv4 as $ipv4_part) { $value = (int) $ipv4_part; if ((string) $value !== $ipv4_part || $value < 0 || $value > 0xFF) { return false; } } } return true; } return false; } /** * Checks if the given IP is a valid IPv6 address * * @codeCoverageIgnore * @deprecated Use {@see IPv6::check_ipv6()} instead * @see check_ipv6 * @param string $ip An IPv6 address * @return bool true if $ip is a valid IPv6 address */ public static function checkIPv6(string $ip) { return self::check_ipv6($ip); } } class_alias('SimplePie\Net\IPv6', 'SimplePie_Net_IPv6'); SSL.pm000055500000040771151755417550005574 0ustar00package Net::SSL; use strict; use MIME::Base64; use Socket; use Carp; use vars qw(@ISA $VERSION $NEW_ARGS); $VERSION = '2.86'; $VERSION = eval $VERSION; require IO::Socket; @ISA=qw(IO::Socket::INET); my %REAL; # private to this package only my $DEFAULT_VERSION = '23'; my $CRLF = "\015\012"; my $SEND_USERAGENT_TO_PROXY = 0; require Crypt::SSLeay; sub _default_context { require Crypt::SSLeay::MainContext; Crypt::SSLeay::MainContext::main_ctx(@_); } sub _alarm_set { return if $^O eq 'MSWin32' or $^O eq 'NetWare'; alarm(shift); } sub new { my($class, %arg) = @_; local $NEW_ARGS = \%arg; $class->SUPER::new(%arg); } sub DESTROY { my $self = shift; delete $REAL{$self}; local $@; eval { $self->SUPER::DESTROY; }; } sub configure { my($self, $arg) = @_; my $ssl_version = delete $arg->{SSL_Version} || $ENV{HTTPS_VERSION} || $DEFAULT_VERSION; my $ssl_debug = delete $arg->{SSL_Debug} || $ENV{HTTPS_DEBUG} || 0; my $ctx = delete $arg->{SSL_Context} || _default_context($ssl_version); *$self->{ssl_ctx} = $ctx; *$self->{ssl_version} = $ssl_version; *$self->{ssl_debug} = $ssl_debug; *$self->{ssl_arg} = $arg; *$self->{ssl_peer_addr} = $arg->{PeerAddr}; *$self->{ssl_peer_port} = $arg->{PeerPort}; *$self->{ssl_new_arg} = $NEW_ARGS; *$self->{ssl_peer_verify} = 0; ## Crypt::SSLeay must also aware the SSL Proxy before calling ## $socket->configure($args). Because the $sock->configure() will ## die when failed to resolve the destination server IP address, ## whether the SSL proxy is used or not! ## - dqbai, 2003-05-10 if (my $proxy = $self->proxy) { ($arg->{PeerAddr}, $arg->{PeerPort}) = split(':',$proxy); $arg->{PeerPort} || croak("no port given for proxy server $proxy"); } $self->SUPER::configure($arg); } # override to make sure there is really a timeout sub timeout { shift->SUPER::timeout || 60; } sub blocking { my $self = shift; $self->SUPER::blocking(@_); } sub connect { my $self = shift; # configure certs on connect() time, so we can throw an undef # and have LWP understand the error eval { $self->configure_certs() }; if($@) { $@ = "configure certs failed: $@; $!"; $self->die_with_error($@); } # finished, update set_verify status if(my $rv = *$self->{ssl_ctx}->set_verify()) { *$self->{ssl_peer_verify} = $rv; } if ($self->proxy) { # don't die() in connect, just return undef and set $@ my $proxy_connect = eval { $self->proxy_connect_helper(@_) }; if(! $proxy_connect || $@) { $@ = "proxy connect failed: $@; $!"; croak($@); } } else { *$self->{io_socket_peername}=@_ == 1 ? $_[0] : IO::Socket::sockaddr_in(@_); if(!$self->SUPER::connect(@_)) { # better to die than return here $@ = "Connect failed: $@; $!"; croak($@); } } my $debug = *$self->{ssl_debug} || 0; my $ssl = Crypt::SSLeay::Conn->new(*$self->{ssl_ctx}, $debug, $self); my $arg = *$self->{ssl_arg}; my $new_arg = *$self->{ssl_new_arg}; $arg->{SSL_Debug} = $debug; # setup SNI if available $ssl->can("set_tlsext_host_name") and $ssl->set_tlsext_host_name(*$self->{ssl_peer_addr}); eval { local $SIG{ALRM} = sub { $self->die_with_error("SSL connect timeout") }; # timeout / 2 because we have 3 possible connects here _alarm_set($self->timeout / 2); my $rv; { local $SIG{PIPE} = \¨ $rv = eval { $ssl->connect; }; } if (not defined $rv or $rv <= 0) { _alarm_set(0); $ssl = undef; # See RT #59312 my %args = (%$arg, %$new_arg); if(*$self->{ssl_version} == 23) { $args{SSL_Version} = 3; # the new connect might itself be overridden with a REAL SSL my $new_ssl = Net::SSL->new(%args); $REAL{$self} = $REAL{$new_ssl} || $new_ssl; return $REAL{$self}; } elsif(*$self->{ssl_version} == 3) { # $self->die_with_error("SSL negotiation failed"); $args{SSL_Version} = 2; my $new_ssl = Net::SSL->new(%args); $REAL{$self} = $new_ssl; return $new_ssl; } else { # don't die, but do set $@, and return undef eval { $self->die_with_error("SSL negotiation failed") }; croak($@); } } _alarm_set(0); }; # odd error in eval {} block, maybe alarm outside the evals if($@) { $@ = "$@; $!"; croak($@); } # successful SSL connection gets stored *$self->{ssl_ssl} = $ssl; $self; } # Delegate these calls to the Crypt::SSLeay::Conn object sub get_peer_certificate { my $self = shift; $self = $REAL{$self} || $self; *$self->{ssl_ssl}->get_peer_certificate(@_); } sub get_peer_verify { my $self = shift; $self = $REAL{$self} || $self; *$self->{ssl_peer_verify}; } sub get_shared_ciphers { my $self = shift; $self = $REAL{$self} || $self; *$self->{ssl_ssl}->get_shared_ciphers(@_); } sub get_cipher { my $self = shift; $self = $REAL{$self} || $self; *$self->{ssl_ssl}->get_cipher(@_); } sub pending { my $self = shift; $self = $REAL{$self} || $self; *$self->{ssl_ssl}->pending(@_); } sub ssl_context { my $self = shift; $self = $REAL{$self} || $self; *$self->{ssl_ctx}; } sub die_with_error { my $self=shift; my $reason=shift; my @err; while(my $err=Crypt::SSLeay::Err::get_error_string()) { push @err, $err; } croak("$reason: " . join( ' | ', @err )); } sub read { my $self = shift; $self = $REAL{$self} || $self; local $SIG{__DIE__} = \&Carp::confess; local $SIG{ALRM} = sub { $self->die_with_error("SSL read timeout") }; _alarm_set($self->timeout); my $n = *$self->{ssl_ssl}->read(@_); _alarm_set(0); $self->die_with_error("read failed") if !defined $n; $n; } sub write { my $self = shift; $self = $REAL{$self} || $self; my $n = *$self->{ssl_ssl}->write(@_); $self->die_with_error("write failed") if !defined $n; $n; } *sysread = \&read; *syswrite = \&write; sub print { my $self = shift; $self = $REAL{$self} || $self; # should we care about $, and $\?? # I think it is too expensive... $self->write(join("", @_)); } sub printf { my $self = shift; $self = $REAL{$self} || $self; my $fmt = shift; $self->write(sprintf($fmt, @_)); } sub getchunk { my $self = shift; $self = $REAL{$self} || $self; my $buf = ''; # warnings my $n = $self->read($buf, 32768); return unless defined $n; $buf; } # This is really inefficient, but we only use it for reading the proxy response # so that does not really matter. sub getline { my $self = shift; $self = $REAL{$self} || $self; my $val=""; my $buf; do { $self->SUPER::recv($buf, 1); $val .= $buf; } until ($buf eq "\n"); $val; } # XXX: no way to disable <$sock>?? (tied handle perhaps?) sub get_lwp_object { my $self = shift; my $lwp_object; my $i = 0; while(1) { package DB; my @stack = caller($i++); last unless @stack; my @stack_args = @DB::args; my $stack_object = $stack_args[0] || next; return $stack_object if ref($stack_object) and $stack_object->isa('LWP::UserAgent'); } return undef; } sub send_useragent_to_proxy { if (my $val = shift) { $SEND_USERAGENT_TO_PROXY = $val; } return $SEND_USERAGENT_TO_PROXY; } sub proxy_connect_helper { my $self = shift; my $proxy = $self->proxy; my ($proxy_host, $proxy_port) = split(':',$proxy); $proxy_port || croak("no port given for proxy server $proxy"); my $proxy_addr = gethostbyname($proxy_host); $proxy_addr || croak("can't resolve proxy server name: $proxy_host, $!"); my($peer_port, $peer_addr) = (*$self->{ssl_peer_port}, *$self->{ssl_peer_addr}); $peer_addr || croak("no peer addr given"); $peer_port || croak("no peer port given"); # see if the proxy should be bypassed my @no_proxy = split( /\s*,\s*/, $ENV{NO_PROXY} || $ENV{no_proxy} || ''); my $is_proxied = 1; my $domain; for $domain (@no_proxy) { if ($peer_addr =~ /\Q$domain\E$/) { $is_proxied = 0; last; } } if ($is_proxied) { $self->SUPER::connect($proxy_port, $proxy_addr) || croak("proxy connect to $proxy_host:$proxy_port failed: $!"); } else { # see RT #57836 my $peer_addr_packed = gethostbyname($peer_addr); $self->SUPER::connect($peer_port, $peer_addr_packed) || croak("proxy bypass to $peer_addr:$peer_addr failed: $!"); } my $connect_string; if ($ENV{"HTTPS_PROXY_USERNAME"} || $ENV{"HTTPS_PROXY_PASSWORD"}) { my $user = $ENV{"HTTPS_PROXY_USERNAME"}; my $pass = $ENV{"HTTPS_PROXY_PASSWORD"}; my $credentials = encode_base64("$user:$pass", ""); $connect_string = join($CRLF, "CONNECT $peer_addr:$peer_port HTTP/1.0", "Proxy-authorization: Basic $credentials" ); } else { $connect_string = "CONNECT $peer_addr:$peer_port HTTP/1.0"; } $connect_string .= $CRLF; if (send_useragent_to_proxy()) { my $lwp_object = $self->get_lwp_object; if($lwp_object && $lwp_object->agent) { $connect_string .= "User-Agent: ".$lwp_object->agent.$CRLF; } } $connect_string .= $CRLF; $self->SUPER::send($connect_string); my $timeout; my $header = ''; # See RT #33954 # See also RT #64054 # Handling incomplete reads and writes better (for some values of # better) may actually make this problem go away, but either way, # there is no good reason to use \d when checking for 0-9 while ($header !~ m{HTTP/[0-9][.][0-9]\s+200\s+.*$CRLF$CRLF}s) { $timeout = $self->timeout(5) unless length $header; my $n = $self->SUPER::sysread($header, 8192, length $header); last if $n <= 0; } $self->timeout($timeout) if defined $timeout; my $conn_ok = ($header =~ m{HTTP/[0-9]+[.][0-9]+\s+200\s+}is) ? 1 : 0; if (not $conn_ok) { croak("PROXY ERROR HEADER, could be non-SSL URL:\n$header"); } $conn_ok; } # code adapted from LWP::UserAgent, with $ua->env_proxy API # see also RT #57836 sub proxy { my $self = shift; my $proxy_server = $ENV{HTTPS_PROXY} || $ENV{https_proxy}; return unless $proxy_server; my($peer_port, $peer_addr) = ( *$self->{ssl_peer_port}, *$self->{ssl_peer_addr} ); $peer_addr || croak("no peer addr given"); $peer_port || croak("no peer port given"); # see if the proxy should be bypassed my @no_proxy = split( /\s*,\s*/, $ENV{NO_PROXY} || $ENV{no_proxy} || '' ); my $is_proxied = 1; for my $domain (@no_proxy) { if ($peer_addr =~ /\Q$domain\E\z/) { return; } } $proxy_server =~ s|\Ahttps?://||i; # sanitize the end of the string too # see also http://www.nntp.perl.org/group/perl.libwww/2012/10/msg7629.html # and https://github.com/nanis/Crypt-SSLeay/pull/1 # Thank you Mark Allen and YigangX Wen $proxy_server =~ s|(:[1-9][0-9]{0,4})/\z|$1|; $proxy_server; } sub configure_certs { my $self = shift; my $ctx = *$self->{ssl_ctx}; my $count = 0; for (qw(HTTPS_PKCS12_FILE HTTPS_CERT_FILE HTTPS_KEY_FILE)) { my $file = $ENV{$_}; if ($file) { (-e $file) or croak("$file file does not exist: $!"); (-r $file) or croak("$file file is not readable"); $count++; if (/PKCS12/) { $count++; $ctx->use_pkcs12_file($file ,$ENV{'HTTPS_PKCS12_PASSWORD'}) || croak("failed to load $file: $!"); last; } elsif (/CERT/) { $ctx->use_certificate_file($file ,1) || croak("failed to load $file: $!"); } elsif (/KEY/) { $ctx->use_PrivateKey_file($file, 1) || croak("failed to load $file: $!"); } else { croak("setting $_ not supported"); } } } # if both configs are set, then verify them if ($count == 2) { if (! $ctx->check_private_key) { croak("Private key and certificate do not match"); } } $count; # number of successful cert loads/checks } sub accept { shift->_unimpl("accept") } sub getc { shift->_unimpl("getc") } sub ungetc { shift->_unimpl("ungetc") } sub getlines { shift->_unimpl("getlines"); } sub _unimpl { my($self, $meth) = @_; croak("$meth not implemented for Net::SSL sockets"); } 1; __END__ =head1 NAME Net::SSL - support for Secure Sockets Layer =head1 METHODS =over 4 =item new Creates a new C object. =item configure Configures a C socket for operation. =item configure_certs Sets up a certificate file to use for communicating with on the socket. =item connect =item die_with_error =item get_cipher =item get_lwp_object Walks up the caller stack and looks for something blessed into the C namespace and returns it. Vaguely deprecated. =item get_peer_certificate Gets the peer certificate from the underlying C object. =item get_peer_verify =item get_shared_ciphers =item getchunk Attempts to read up to 32KiB of data from the socket. Returns C if nothing was read, otherwise returns the data as a scalar. =item pending Provides access to OpenSSL's C attribute on the SSL connection object. =item getline Reads one character at a time until a newline is encountered, and returns the line, including the newline. Grossly inefficient. =item print Concatenates the input parameters and writes them to the socket. Does not honour C<$,> nor C<$/>. Returns the number of bytes written. =item printf Performs a C of the input parameters (thus, the first parameter must be the format), and writes the result to the socket. Returns the number of bytes written. =item proxy Returns the hostname of an https proxy server, as specified by the C environment variable. =item proxy_connect_helper Helps set up a connection through a proxy. =item read Performs a read on the socket and returns the result. =item ssl_context =item sysread Is an alias of C. =item timeout Returns the timeout value of the socket as defined by the implementing class or 60 seconds by default. =item blocking Returns a boolean indicating whether the underlying socket is in blocking mode. By default, Net::SSL sockets are in blocking mode. $sock->blocking(0); # set to non-blocking mode This method simply calls the underlying C method of the IO::Socket object. =item write Writes the parameters passed in (thus, a list) to the socket. Returns the number of bytes written. =item syswrite Is an alias of C. =item accept Not yet implemented. Will die if called. =item getc Not yet implemented. Will die if called. =item getlines Not yet implemented. Will die if called. =item ungetc Not yet implemented. Will die if called. =item send_useragent_to_proxy By default (as of version 2.80 of C in the 0.54 distribution of Crypt::SSLeay), the user agent string is no longer sent to the proxy (but will continue to be sent to the remote host). The previous behaviour was of marginal benefit, and could cause fatal errors in certain scenarios (see CPAN bug #4759) and so no longer happens by default. To reinstate the old behaviour, call C with a true value (usually 1). =back =head1 DIAGNOSTICS "no port given for proxy server " A proxy was specified for configuring a socket, but no port number was given. Ensure that the proxy is specified as a host:port pair, such as C. "configure certs failed: ; " "proxy connect failed: ; " "Connect failed: ; " During connect(). =head2 SEE ALSO =over 4 =item IO::Socket::INET C is implemented by subclassing C, hence methods not specifically overridden are defined by that package. =item Net::SSLeay A package that provides a Perl-level interface to the C secure sockets layer library. =back =cut