Compare commits
162 Commits
Author | SHA1 | Date |
---|---|---|
rofl0r | 821249f22a | |
rofl0r | fffd2532ad | |
rofl0r | 282ac7dd02 | |
rofl0r | 1d0bc349eb | |
Guilherme Janczak | 0279dda939 | |
wzy | d5cc80ae16 | |
rofl0r | 0c795085fa | |
Wu Zhenyu | 42d2d95160 | |
rofl0r | 133e06b3f0 | |
rofl0r | 2d265582a2 | |
rofl0r | 66f99b19dd | |
rofl0r | 199d03d8b4 | |
rofl0r | 060801d8c8 | |
rofl0r | 09142579c5 | |
rofl0r | 916d2d7da1 | |
rofl0r | 4b531806b2 | |
Zenithal | 9b42da71f4 | |
Freed-Wu | 04023d3811 | |
rofl0r | 0a4daa62d6 | |
Recolic Keghart | 0000000062 | |
rofl0r | 07c15a02f6 | |
rofl0r | 2cc014995e | |
Vladimir Panteleev | 6abeb53e69 | |
Vladimir Panteleev | 70629aaf25 | |
rofl0r | a12cf0a516 | |
Eero Häkkinen | 2739fb5416 | |
rofl0r | 4a963b2feb | |
rofl0r | e20c08fe47 | |
rofl0r | 4a013fe6a5 | |
rofl0r | d415d8a5ed | |
rofl0r | 063ac681da | |
rofl0r | b83e90dcaf | |
rofl0r | 7de7dd0de1 | |
rofl0r | 1015efaf16 | |
Fabrice Fontaine | 83bfa0b61d | |
rofl0r | 931e0df9f8 | |
rofl0r | 092d7042e0 | |
rofl0r | 6af2686a52 | |
rofl0r | 918855deed | |
rofl0r | 181cc0f414 | |
rofl0r | 3721f7e144 | |
rofl0r | 6c029fdf47 | |
rofl0r | 596f0028cb | |
rofl0r | fa9644dc27 | |
Alexandre Viau | 159ab94635 | |
rofl0r | 583343a2ef | |
rofl0r | 0069fcd53e | |
rofl0r | 13680e775d | |
rofl0r | 55dce2c040 | |
rofl0r | 82c766461c | |
rofl0r | 59e8d1710a | |
rofl0r | 452830283c | |
rofl0r | 486f8200ad | |
rofl0r | c99d97983e | |
rofl0r | 7fe8139496 | |
rofl0r | 1e00b9ac1e | |
rofl0r | 1221c5e93a | |
rofl0r | e6c4764660 | |
rofl0r | 2ab631918d | |
rofl0r | 3e791fd797 | |
rofl0r | 3a5050bec2 | |
rofl0r | 3dfda493d8 | |
rofl0r | ed8f8444ab | |
rofl0r | 12e5da1b90 | |
rofl0r | 121c582d9c | |
rofl0r | acf2f4725d | |
Ethan F | 0ee5db605b | |
tom gilon | bf2ef2ce38 | |
tom gilon | de31961349 | |
Solar Flare | b8fa2a7405 | |
Solar Flare | 0a8663c845 | |
rofl0r | 86408cd806 | |
rofl0r | ea187938e1 | |
rofl0r | 962373e5c6 | |
rofl0r | de4460fbd1 | |
rofl0r | 5ad7c2a183 | |
rofl0r | 067885694d | |
rofl0r | e895fb713a | |
rofl0r | b8cdfe842c | |
rofl0r | 9f17774b99 | |
rofl0r | dbec605e2c | |
rofl0r | 5c8f9a2922 | |
rofl0r | 50c079d4b4 | |
Tom Li | 11988579f5 | |
Tom Li | db5cd6b699 | |
rofl0r | a6959ee715 | |
rofl0r | 49bf4ba772 | |
rofl0r | 2213afb6f0 | |
rofl0r | bd7e8a1da1 | |
rofl0r | 416d481ac9 | |
amyangfei | eb36238c8a | |
amyangfei | 275e64499e | |
rofl0r | 1c8f8e4e7e | |
rofl0r | d21af711d8 | |
rofl0r | 49d8ac9338 | |
rofl0r | bb30d867fe | |
rofl0r | 06c20ed394 | |
rofl0r | 831df039bd | |
rofl0r | 1a62ec60af | |
WHR | 35a674bdbc | |
papadave | a1f7007a46 | |
rofl0r | 3366dc3131 | |
rofl0r | b299193d13 | |
rofl0r | 2f3d33dd47 | |
rofl0r | d28f4df8e2 | |
rofl0r | 03880ce695 | |
rofl0r | cc7bc891ff | |
rofl0r | 3b5f41028b | |
Antonio Quartulli | 46647bee44 | |
rofl0r | bb3df1e440 | |
rofl0r | 7a233fb1f0 | |
rofl0r | cd4ced1d52 | |
rofl0r | cb70ab5f8f | |
Jatin Rungta | c91e6a09ef | |
rofl0r | bf6eeff75a | |
rofl0r | 6ae959e051 | |
Carlos Maddela | 5ed5089733 | |
Carlos Maddela | 8ddc8a6da3 | |
Carlos Maddela | 167780ce36 | |
Carlos Maddela | 4b413c902f | |
Carlos Maddela | 6dcaf533d1 | |
Carlos Maddela | 0bd2130352 | |
forkbomber | cf9a16de06 | |
rofl0r | c883cd4940 | |
Jay Taylor | 0f6b226b15 | |
rofl0r | 260578d00e | |
rofl0r | e527b9ee64 | |
Carlos Maddela | 635ded3393 | |
Carlos Maddela | 993dfc059d | |
rofl0r | f1e5f2ba01 | |
rofl0r | 8870140ff0 | |
rofl0r | aea9172653 | |
rofl0r | afdbfcf40c | |
rofl0r | 058adbcac2 | |
rofl0r | b64c89e0e4 | |
rofl0r | a1c31e73b6 | |
Alexander Batischev | f85cecdabe | |
rofl0r | 672bf7661d | |
rofl0r | 4c3be5e1e3 | |
rofl0r | 0e0e35927c | |
rofl0r | 205004fa2a | |
rofl0r | 50c84176da | |
rofl0r | 1294d0a004 | |
rofl0r | e9bf9623ba | |
rofl0r | 8a7081409e | |
rofl0r | 32df7ff152 | |
rofl0r | 097c7f9125 | |
rofl0r | 2237749567 | |
rofl0r | 9969dd3a22 | |
rofl0r | d900b090fe | |
rofl0r | afe6171cad | |
rofl0r | 51b2eb91ce | |
rofl0r | ae16ae9fc9 | |
rofl0r | 338b9ce4e3 | |
rofl0r | c6553c2cc5 | |
rofl0r | 49adb6ce29 | |
rofl0r | c7fa7bf86a | |
rofl0r | 29df9abec3 | |
rofl0r | 2182eff358 | |
rofl0r | 53c6c2ca9b | |
rofl0r | c9c51d6705 | |
rofl0r | fda4ba37ec |
|
@ -1,4 +1,5 @@
|
|||
proxychains4
|
||||
proxychains4-daemon
|
||||
*.bz2
|
||||
*.xz
|
||||
*.o
|
||||
|
|
45
Makefile
45
Makefile
|
@ -11,25 +11,31 @@ bindir = $(exec_prefix)/bin
|
|||
prefix = /usr/local/
|
||||
includedir = $(prefix)/include
|
||||
libdir = $(prefix)/lib
|
||||
sysconfdir=$(prefix)/etc
|
||||
sysconfdir = $(prefix)/etc
|
||||
zshcompletiondir = $(prefix)/share/zsh/site-functions
|
||||
|
||||
SRCS = $(sort $(wildcard src/*.c))
|
||||
OBJS = $(SRCS:.c=.o)
|
||||
LOBJS = src/nameinfo.o src/version.o \
|
||||
src/core.o src/common.o src/libproxychains.o src/shm.o \
|
||||
src/allocator_thread.o src/ip_type.o src/stringdump.o \
|
||||
OBJS = src/common.o src/main.o
|
||||
|
||||
DOBJS = src/daemon/hsearch.o \
|
||||
src/daemon/sblist.o src/daemon/sblist_delete.o \
|
||||
src/daemon/daemon.o src/daemon/udpserver.o
|
||||
|
||||
LOBJS = src/version.o \
|
||||
src/core.o src/common.o src/libproxychains.o \
|
||||
src/allocator_thread.o src/rdns.o \
|
||||
src/hostsreader.o src/hash.o src/debug.o
|
||||
|
||||
|
||||
GENH = src/version.h
|
||||
|
||||
CFLAGS += -Wall -O0 -g -std=c99 -D_GNU_SOURCE -pipe
|
||||
NO_AS_NEEDED = -Wl,--no-as-needed
|
||||
LIBDL = -ldl
|
||||
LDFLAGS = -fPIC $(NO_AS_NEEDED)
|
||||
LDFLAGS = -fPIC $(NO_AS_NEEDED) $(LIBDL) $(PTHREAD)
|
||||
INC =
|
||||
PIC = -fPIC
|
||||
AR = $(CROSS_COMPILE)ar
|
||||
RANLIB = $(CROSS_COMPILE)ranlib
|
||||
SOCKET_LIBS =
|
||||
|
||||
LDSO_SUFFIX = so
|
||||
LD_SET_SONAME = -Wl,-soname=
|
||||
|
@ -40,13 +46,14 @@ LDSO_PATHNAME = libproxychains4.$(LDSO_SUFFIX)
|
|||
SHARED_LIBS = $(LDSO_PATHNAME)
|
||||
ALL_LIBS = $(SHARED_LIBS)
|
||||
PXCHAINS = proxychains4
|
||||
ALL_TOOLS = $(PXCHAINS)
|
||||
PXCHAINS_D = proxychains4-daemon
|
||||
ALL_TOOLS = $(PXCHAINS) $(PXCHAINS_D)
|
||||
ALL_CONFIGS = src/proxychains.conf
|
||||
ZSH_COMPLETION = completions/zsh/_proxychains4
|
||||
|
||||
-include config.mak
|
||||
|
||||
CFLAGS+=$(USER_CFLAGS) $(MAC_CFLAGS)
|
||||
LDFLAGS+=$(USER_LDFLAGS)
|
||||
CFLAGS_MAIN=-DLIB_DIR=\"$(libdir)\" -DSYSCONFDIR=\"$(sysconfdir)\" -DDLL_NAME=\"$(LDSO_PATHNAME)\"
|
||||
|
||||
|
||||
|
@ -63,14 +70,18 @@ $(DESTDIR)$(libdir)/%: %
|
|||
$(DESTDIR)$(sysconfdir)/%: src/%
|
||||
$(INSTALL) -D -m 644 $< $@
|
||||
|
||||
$(DESTDIR)$(zshcompletiondir)/%: completions/zsh/%
|
||||
$(INSTALL) -D -m 644 $< $@
|
||||
|
||||
install-libs: $(ALL_LIBS:%=$(DESTDIR)$(libdir)/%)
|
||||
install-tools: $(ALL_TOOLS:%=$(DESTDIR)$(bindir)/%)
|
||||
install-config: $(ALL_CONFIGS:src/%=$(DESTDIR)$(sysconfdir)/%)
|
||||
install-zsh-completion: $(ZSH_COMPLETION:completions/zsh/%=$(DESTDIR)$(zshcompletiondir)/%)
|
||||
|
||||
clean:
|
||||
rm -f $(ALL_LIBS)
|
||||
rm -f $(ALL_TOOLS)
|
||||
rm -f $(OBJS)
|
||||
rm -f $(OBJS) $(LOBJS) $(DOBJS)
|
||||
rm -f $(GENH)
|
||||
|
||||
src/version.h: $(wildcard VERSION .git)
|
||||
|
@ -82,10 +93,14 @@ src/version.o: src/version.h
|
|||
$(CC) $(CPPFLAGS) $(CFLAGS) $(CFLAGS_MAIN) $(INC) $(PIC) -c -o $@ $<
|
||||
|
||||
$(LDSO_PATHNAME): $(LOBJS)
|
||||
$(CC) -shared $(LDFLAGS) $(LD_SET_SONAME)$(LDSO_PATHNAME) -lpthread $(LIBDL) -o $@ $(LOBJS)
|
||||
$(CC) $(LDFLAGS) $(FAT_LDFLAGS) $(LD_SET_SONAME)$(LDSO_PATHNAME) \
|
||||
$(USER_LDFLAGS) -shared -o $@ $^ $(SOCKET_LIBS)
|
||||
|
||||
$(ALL_TOOLS): $(OBJS)
|
||||
$(CC) $(LDFLAGS) src/main.o src/common.o -o $(PXCHAINS)
|
||||
$(PXCHAINS): $(OBJS)
|
||||
$(CC) $^ $(FAT_BIN_LDFLAGS) $(USER_LDFLAGS) $(LIBDL) -o $@
|
||||
|
||||
$(PXCHAINS_D): $(DOBJS)
|
||||
$(CC) $^ $(FAT_BIN_LDFLAGS) $(USER_LDFLAGS) -o $@
|
||||
|
||||
|
||||
.PHONY: all clean install install-config install-libs install-tools
|
||||
.PHONY: all clean install install-config install-libs install-tools install-zsh-completion
|
||||
|
|
95
README
95
README
|
@ -1,4 +1,4 @@
|
|||
ProxyChains-NG ver 4.9 README
|
||||
ProxyChains-NG ver 4.17 README
|
||||
=============================
|
||||
|
||||
ProxyChains is a UNIX program, that hooks network-related libc functions
|
||||
|
@ -16,7 +16,7 @@ ProxyChains-NG ver 4.9 README
|
|||
If your program doesn't work with proxychains, consider using an
|
||||
iptables based solution instead; this is much more robust.
|
||||
|
||||
Supported Platforms: Linux, BSD, Mac.
|
||||
Supported Platforms: Linux, BSD, Mac, Haiku.
|
||||
|
||||
|
||||
*********** ATTENTION ***********
|
||||
|
@ -52,6 +52,69 @@ ProxyChains-NG ver 4.9 README
|
|||
|
||||
Changelog:
|
||||
----------
|
||||
Version 4.17
|
||||
- add hook for close_range function, fixing newer versions of openssh
|
||||
- fat-binary-m1 option for mac
|
||||
- fix DNS error handling in proxy_dns_old
|
||||
- simplify init code
|
||||
- fix openbsd preloading
|
||||
- fix double-close in multithreaded apps
|
||||
- various improvements to configure script
|
||||
|
||||
Version 4.16
|
||||
- fix regression in configure script linker flag detection
|
||||
- remove 10 year old workaround for wrong glibc getnameinfo signature
|
||||
- support for new DYLD hooking method for OSX Monterey
|
||||
- netbsd compilation fix
|
||||
- support IPv6 localnets
|
||||
- more user-friendly error message when execvp fails
|
||||
- proxy_getaddrinfo(): fill in ai_socktype if requested
|
||||
|
||||
Version 4.15
|
||||
- fix configure script for buggy binutils version
|
||||
- initialize rand_seed with nano-second granularity
|
||||
- add support for numeric ipv6 in getaddrinfo
|
||||
- fix bug in getaddrinfo when node is null and !passive
|
||||
- add dnat feature
|
||||
- add raw proxy type
|
||||
- add haiku support
|
||||
- add proxy_dns_old to emulate proxychains 3.1 behaviour
|
||||
- add new proxy_dns_daemon feature (experimental)
|
||||
- various other fixes
|
||||
|
||||
Version 4.14
|
||||
- allow alternative proto://user:pass@ip:port syntax for proxylist
|
||||
- fix endless loop in round robin mode when all proxies are down (#147)
|
||||
- fix compilation on android (#265)
|
||||
- fix fd leak in forked processes (#273)
|
||||
- skip connection attempt to nullrouted ips
|
||||
- allow hostnames for proxylist under specific circumstances
|
||||
|
||||
Version 4.13
|
||||
- fix robustness of DNS lookup thread and a segfault
|
||||
- fix socks5 user/pass auth on non-conforming servers
|
||||
- fix memory leak
|
||||
- add support for Solaris
|
||||
|
||||
Version 4.12
|
||||
- fix several build issues
|
||||
- for MAC
|
||||
- with -pie
|
||||
- with custom CC
|
||||
- compatibility fix for some GUI apps (8870140)
|
||||
- compatibility fix for some HTTP proxies (cf9a16d)
|
||||
- fix several warnings for cleaner build on debian
|
||||
- fix random_chain on OSX (0f6b226)
|
||||
|
||||
Version 4.11
|
||||
- preliminary IPv6 support
|
||||
- fixed bug in hostsreader
|
||||
- preliminary support for usage on OpenBSD (caveat emptor)
|
||||
|
||||
Version 4.10
|
||||
- fix regression in linking order with custom LDFLAGS
|
||||
- fix segfault in DNS mapping code in programs with > ~400 different lookups
|
||||
|
||||
Version 4.9
|
||||
- fix a security issue CVE-2015-3887
|
||||
- add sendto hook to handle MSG_FASTOPEN flag
|
||||
|
@ -165,7 +228,7 @@ specified by proxychains.conf
|
|||
|
||||
Usage Example:
|
||||
|
||||
$ proxychains -f /etc/proxychains-other.conf targethost2.com
|
||||
$ proxychains -f /etc/proxychains-other.conf telnet targethost2.com
|
||||
|
||||
in this example it will use different configuration file then proxychains.conf
|
||||
to connect to targethost2.com host.
|
||||
|
@ -177,9 +240,33 @@ Usage Example:
|
|||
in this example it will resolve targethost.com through proxy(or chained proxies)
|
||||
specified by proxychains.conf
|
||||
|
||||
Known Problems:
|
||||
---------------
|
||||
- newer versions of nmap try to determine the network interface to use
|
||||
even if it's not needed (like when doing simple syn scans which use the
|
||||
standard POSIX socket API. this results in errors when proxychains hands
|
||||
out an ip address to a reserved address space.
|
||||
possible workarounds: disable proxy_dns, use a numeric ip, or use nmap's
|
||||
native support for SOCKS proxies.
|
||||
|
||||
- Mac OS X 10.11 (El Capitan) ships with a new security feature called SIP
|
||||
that prevents hooking of system apps.
|
||||
workarounds are to partially disable SIP by issuing
|
||||
csrutil enable --without debug in recovery mode,
|
||||
or to copy the system binary into the home directory and run it from there.
|
||||
see github issue #78 for details.
|
||||
|
||||
- the glibc dynlinker has a bug or security feature that inhibits dlopen()ed
|
||||
modules from being subject to the same dlsym hooks as installed for the main
|
||||
program. this mainly affects scripting languages such as perl or python
|
||||
that heavily rely on dlopen() for modules written in C to work.
|
||||
there are unconfirmed reports that it works as root though.
|
||||
musl libc is unaffected from the bug.
|
||||
|
||||
|
||||
Community:
|
||||
----------
|
||||
#proxychains on irc.freenode.net
|
||||
#proxychains on irc.libera.chat
|
||||
|
||||
Donations:
|
||||
----------
|
||||
|
|
|
@ -0,0 +1,8 @@
|
|||
#compdef proxychains4
|
||||
|
||||
_arguments \
|
||||
'(- : *)--help[More help in README file]' \
|
||||
'-q[makes proxychains quiet - this overrides the config setting]' \
|
||||
'-f[allows one to manually specify a configfile to use]: :_files' \
|
||||
'(-)1: :{_command_names -e}' \
|
||||
'*:: :_normal'
|
|
@ -1,35 +1,95 @@
|
|||
#!/bin/sh
|
||||
|
||||
prefix=/usr/local
|
||||
OUR_CPPFLAGS=
|
||||
|
||||
ismac() {
|
||||
uname -s | grep Darwin >/dev/null
|
||||
# Get a temporary filename
|
||||
fail() { printf "%s\n" "$1" >&2 ; exit 1 ; }
|
||||
i=0
|
||||
set -C
|
||||
while : ; do i=$(($i+1))
|
||||
tmpc="./conf$$-$PPID-$i.c"
|
||||
2>|/dev/null > "$tmpc" && break
|
||||
test "$i" -gt 50 && fail "$0: cannot create temporary file $tmpc"
|
||||
done
|
||||
set +C
|
||||
trap 'rm "$tmpc"' EXIT INT QUIT TERM HUP
|
||||
|
||||
check_compile() {
|
||||
printf "checking %s ... " "$1"
|
||||
printf "$3" > "$tmpc"
|
||||
local res=0
|
||||
$CC $OUR_CPPFLAGS $CPPFLAGS $2 $CFLAGS "$tmpc" -o "$tmpc".out >/dev/null 2>&1 \
|
||||
|| res=1
|
||||
test x$res = x0 && \
|
||||
{ printf "yes\n" ; test x"$2" = x || OUR_CPPFLAGS="$OUR_CPPFLAGS $2" ; } \
|
||||
|| printf "no\n"
|
||||
rm -f "$tmpc".out
|
||||
return $res
|
||||
}
|
||||
|
||||
isx86_64() {
|
||||
uname -m | grep -i X86_64 >/dev/null
|
||||
get_define() {
|
||||
$CC $OUR_CPPFLAGS $CPPFLAGS $CFLAGS -dM -E - </dev/null | grep "$1"
|
||||
}
|
||||
|
||||
isbsd() {
|
||||
uname -s | grep BSD >/dev/null
|
||||
get_define_stripped() {
|
||||
local output=$(get_define "$1")
|
||||
test "$?" = 0 || return 1
|
||||
printf "%s\n" "$output" | sed 's/^.* .* //'
|
||||
}
|
||||
|
||||
isopenbsd() {
|
||||
uname -s | grep OpenBSD >/dev/null
|
||||
check_define() {
|
||||
printf "checking whether \$CC defines %s ... " "$1"
|
||||
local res=1
|
||||
get_define "$1" >/dev/null && res=0
|
||||
test x$res = x0 && printf "yes\n" || printf "no\n"
|
||||
return $res
|
||||
}
|
||||
|
||||
check_compile_run() {
|
||||
printf "checking %s ... " "$1"
|
||||
printf "$2" > "$tmpc"
|
||||
local res=0
|
||||
$CC $OUR_CPPFLAGS $CPPFLAGS $CFLAGS "$tmpc" -o "$tmpc".out >/dev/null 2>&1 \
|
||||
|| res=1
|
||||
test x$res = x0 && { "$tmpc".out || res=1 ; }
|
||||
rm -f "$tmpc".out
|
||||
test x$res = x0 && printf "yes\n" || printf "no\n"
|
||||
return $res
|
||||
}
|
||||
|
||||
check_link_silent() {
|
||||
printf "$2" > "$tmpc"
|
||||
local res=0
|
||||
$CC $OUR_CPPFLAGS $CPPFLAGS $1 $CFLAGS "$tmpc" -o "$tmpc".out >/dev/null 2>&1 || res=1
|
||||
rm -f "$tmpc".out
|
||||
return $res
|
||||
}
|
||||
|
||||
check_link() {
|
||||
printf "checking %s ... " "$1"
|
||||
local res=0
|
||||
check_link_silent "$2" "$3" || res=1
|
||||
test x$res = x0 && printf "yes\n" || printf "no\n"
|
||||
return $res
|
||||
}
|
||||
|
||||
usage() {
|
||||
echo "supported arguments"
|
||||
echo "--prefix=/path default: $prefix"
|
||||
echo "--exec_prefix=/path default: $prefix/bin"
|
||||
echo "--bindir=/path default: $prefix/bin"
|
||||
echo "--libdir=/path default: $prefix/lib"
|
||||
echo "--includedir=/path default: $prefix/include"
|
||||
echo "--sysconfdir=/path default: $prefix/etc"
|
||||
echo "--ignore-cve default: no"
|
||||
echo "--prefix=/path default: $prefix"
|
||||
echo "--exec_prefix=/path default: $prefix/bin"
|
||||
echo "--bindir=/path default: $prefix/bin"
|
||||
echo "--libdir=/path default: $prefix/lib"
|
||||
echo "--includedir=/path default: $prefix/include"
|
||||
echo "--sysconfdir=/path default: $prefix/etc"
|
||||
echo "--ignore-cve default: no"
|
||||
echo " if set to yes ignores CVE-2015-3887 and makes it possible"
|
||||
echo " to preload from current dir (insecure)"
|
||||
ismac && isx86_64 && echo "--fat-binary : build for both i386 and x86_64 architectures on 64-bit Macs"
|
||||
echo " to preload from current dir (possibly insecure, but handy)"
|
||||
echo "--fat-binary : build for both i386 and x86_64 architectures on 64-bit Macs"
|
||||
echo "--fat-binary-m1 : build for both arm64e and x86_64 architectures on M1 Macs"
|
||||
echo "--fat-binary-m2 : build for arm64, arm64e and x86_64 architectures on M2+ Macs"
|
||||
echo "--hookmethod=dlsym|dyld hook method for osx. default: auto"
|
||||
echo " if OSX >= 12 is detected, dyld method will be used if auto."
|
||||
echo "--help : show this text"
|
||||
exit 1
|
||||
}
|
||||
|
@ -42,7 +102,11 @@ spliteq() {
|
|||
}
|
||||
|
||||
fat_binary=
|
||||
fat_binary_m1=
|
||||
fat_binary_m2=
|
||||
ignore_cve=no
|
||||
hookmethod=auto
|
||||
|
||||
parsearg() {
|
||||
case "$1" in
|
||||
--prefix=*) prefix=`spliteq $1`;;
|
||||
|
@ -53,7 +117,10 @@ parsearg() {
|
|||
--sysconfdir=*) sysconfdir=`spliteq $1`;;
|
||||
--ignore-cve) ignore_cve=1;;
|
||||
--ignore-cve=*) ignore_cve=`spliteq $1`;;
|
||||
--hookmethod=*) hookmethod=`spliteq $1`;;
|
||||
--fat-binary) fat_binary=1;;
|
||||
--fat-binary-m1) fat_binary_m1=1;;
|
||||
--fat-binary-m2) fat_binary_m2=1;;
|
||||
--help) usage;;
|
||||
esac
|
||||
}
|
||||
|
@ -89,33 +156,161 @@ if [ -z "$CC" ] ; then
|
|||
CC=cc
|
||||
fi
|
||||
|
||||
echo CC?=$CC>config.mak
|
||||
[ -z "$CPPFLAGS" ] || echo CPPFLAGS?=$CPPFLAGS>>config.mak
|
||||
[ -z "$CFLAGS" ] || echo USER_CFLAGS?=$CFLAGS>>config.mak
|
||||
[ -z "$LDFLAGS" ] || echo USER_LDFLAGS?=$LDFLAGS>>config.mak
|
||||
echo > config.mak
|
||||
|
||||
bsd_detected=false
|
||||
isbsd() {
|
||||
$bsd_detected
|
||||
}
|
||||
mac_detected=false
|
||||
ismac() {
|
||||
$mac_detected
|
||||
}
|
||||
mac_64=false
|
||||
ismac64() {
|
||||
$mac_64
|
||||
}
|
||||
solaris_detected=false
|
||||
issolaris() {
|
||||
$solaris_detected
|
||||
}
|
||||
haiku_detected=false
|
||||
ishaiku() {
|
||||
$haiku_detected
|
||||
}
|
||||
|
||||
check_compile 'whether C compiler works' '' 'int main() {return 0;}' || fail 'error: install a C compiler and library'
|
||||
check_compile 'whether libc headers are complete' '' '#include <netdb.h>\nint main() {return 0;}' || fail 'error: necessary libc headers are not installed'
|
||||
check_compile 'whether C compiler understands -Wno-unknown-pragmas' '-Wno-unknown-pragmas' 'int main() {return 0;}'
|
||||
|
||||
if ! check_compile 'whether getnameinfo() servlen argument is POSIX compliant (socklen_t)' "-DGN_NODELEN_T=socklen_t -DGN_SERVLEN_T=socklen_t -DGN_FLAGS_T=int" \
|
||||
'#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, socklen_t, int);int main() {\nreturn 0;}' ; then
|
||||
# GLIBC < 2.14
|
||||
if ! check_compile 'whether getnameinfo() flags argument is unsigned' "-DGN_NODELEN_T=socklen_t -DGN_SERVLEN_T=socklen_t -DGN_FLAGS_T=unsigned" \
|
||||
'#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, socklen_t, unsigned);int main() {\nreturn 0;}' ; then
|
||||
if ! check_compile 'whether getnameinfo() servlen argument is size_t' "-DGN_NODELEN_T=socklen_t -DGN_SERVLEN_T=size_t -DGN_FLAGS_T=int" \
|
||||
'#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, socklen_t, char *, size_t, int);int main() {\nreturn 0;}' ; then
|
||||
# OpenBSD & FreeBSD
|
||||
if ! check_compile 'whether getnameinfo() servlen and nodelen argument is size_t' "-DGN_NODELEN_T=size_t -DGN_SERVLEN_T=size_t -DGN_FLAGS_T=int" \
|
||||
'#define _GNU_SOURCE\n#include <netdb.h>\nint getnameinfo(const struct sockaddr *, socklen_t, char *, size_t, char *, size_t, int);int main() {\nreturn 0;}' ; then
|
||||
fail "failed to detect getnameinfo signature"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
check_compile 'whether we have GNU-style getservbyname_r()' "-DHAVE_GNU_GETSERVBYNAME_R" \
|
||||
'#define _GNU_SOURCE\n#include <netdb.h>\nint main() {\nstruct servent *se = 0;struct servent se_buf;char buf[1024];\ngetservbyname_r("foo", (void*) 0, &se_buf, buf, sizeof(buf), &se);\nreturn 0;}'
|
||||
|
||||
check_compile 'whether we have pipe2() and O_CLOEXEC' "-DHAVE_PIPE2" \
|
||||
'#define _GNU_SOURCE\n#include <fcntl.h>\n#include <unistd.h>\nint main() {\nint pipefd[2];\npipe2(pipefd, O_CLOEXEC);\nreturn 0;}'
|
||||
|
||||
check_compile 'whether we have SOCK_CLOEXEC' "-DHAVE_SOCK_CLOEXEC" \
|
||||
'#define _GNU_SOURCE\n#include <sys/socket.h>\nint main() {\nreturn socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);}'
|
||||
|
||||
check_compile 'whether we have clock_gettime' "-DHAVE_CLOCK_GETTIME" \
|
||||
'#define _GNU_SOURCE\n#include <time.h>\nint main() {\nstruct timespec now;clock_gettime(CLOCK_REALTIME, &now);\nreturn now.tv_sec ^ now.tv_nsec;}'
|
||||
|
||||
check_define __APPLE__ && {
|
||||
mac_detected=true
|
||||
check_define __x86_64__ && mac_64=true
|
||||
if test "$hookmethod" = auto ; then
|
||||
osver=$(get_define_stripped __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ 2>/dev/null)
|
||||
test "$osver" -gt $((120000 - 1)) && hookmethod=dyld
|
||||
fi
|
||||
}
|
||||
check_define __FreeBSD__ && bsd_detected=true
|
||||
check_define __OpenBSD__ && {
|
||||
bsd_detected=true
|
||||
echo "CFLAGS+=-DIS_OPENBSD">>config.mak
|
||||
check_compile_run 'whether OpenBSDs fclose() (illegally) calls close()' \
|
||||
'#include <stdio.h>\n#include<stdlib.h>\nint close(int x){exit(0);}int main(){fclose(stdin);return 1;}' && \
|
||||
OUR_CPPFLAGS="$OUR_CPPFLAGS -DBROKEN_FCLOSE"
|
||||
}
|
||||
check_define __sun && check_define __SVR4 && solaris_detected=true
|
||||
check_define __HAIKU__ && haiku_detected=true
|
||||
|
||||
echo "CC=$CC">>config.mak
|
||||
[ -z "$CPPFLAGS" ] || echo "CPPFLAGS=$CPPFLAGS">>config.mak
|
||||
[ -z "$CFLAGS" ] || echo "USER_CFLAGS=$CFLAGS">>config.mak
|
||||
[ -z "$LDFLAGS" ] || echo "USER_LDFLAGS=$LDFLAGS">>config.mak
|
||||
echo prefix=$prefix>>config.mak
|
||||
echo exec_prefix=$exec_prefix>>config.mak
|
||||
echo bindir=$bindir>>config.mak
|
||||
echo libdir=$libdir>>config.mak
|
||||
echo includedir=$includedir>>config.mak
|
||||
echo sysconfdir=$sysconfdir>>config.mak
|
||||
[ "$ignore_cve" = "no" ] && echo CPPFLAGS+= -DSUPER_SECURE>>config.mak
|
||||
[ "$ignore_cve" = "no" ] && echo "CPPFLAGS+= -DSUPER_SECURE">>config.mak
|
||||
[ -z "$OUR_CPPFLAGS" ] || echo "CPPFLAGS+= $OUR_CPPFLAGS" >>config.mak
|
||||
|
||||
check_link "whether we can use -Wl,--no-as-needed" "-Wl,--no-as-needed" \
|
||||
"int main() { return 0; }" || echo NO_AS_NEEDED= >> config.mak
|
||||
|
||||
LD_SONAME_FLAG=
|
||||
printf "checking what's the option to use in linker to set library name ... "
|
||||
for o in --soname -h -soname -install_name; do
|
||||
check_link_silent "-shared -Wl,$o,libconftest.so" "void test_func(int a) {}" && LD_SONAME_FLAG=$o && break
|
||||
done
|
||||
if [ -z "$LD_SONAME_FLAG" ]; then
|
||||
printf '\ncannot find an option to set library name\n'
|
||||
exit 1
|
||||
fi
|
||||
echo "$LD_SONAME_FLAG"
|
||||
echo "LD_SET_SONAME = -Wl,$LD_SONAME_FLAG," >> config.mak
|
||||
|
||||
if check_link "checking whether we can use -ldl" "-ldl" \
|
||||
"int main(){return 0;}" ; then
|
||||
echo "LIBDL = -ldl" >> config.mak
|
||||
fi
|
||||
|
||||
if check_link "checking whether we can use -lpthread" "-lpthread" \
|
||||
"int main(){return 0;}" ; then
|
||||
echo "PTHREAD = -lpthread" >> config.mak
|
||||
else
|
||||
check_link "checking whether we can use -pthread" "-pthread" \
|
||||
"int main(){return 0;}" || fail "no pthread support detected"
|
||||
echo "PTHREAD = -pthread" >> config.mak
|
||||
fi
|
||||
|
||||
make_cmd=make
|
||||
if ismac ; then
|
||||
echo NO_AS_NEEDED=>>config.mak
|
||||
echo LDSO_SUFFIX=dylib>>config.mak
|
||||
echo MAC_CFLAGS+=-DIS_MAC=1>>config.mak
|
||||
if isx86_64 && [ "$fat_binary" = 1 ] ; then
|
||||
echo "Configuring a fat binary for i386 and x86_64"
|
||||
echo MAC_CFLAGS+=-arch i386 -arch x86_64>>config.mak
|
||||
echo LDFLAGS+=-arch i386 -arch x86_64>>config.mak
|
||||
if test "$hookmethod" = dyld ; then
|
||||
echo "using Monterey style DYLD hooking"
|
||||
echo "CFLAGS+=-DMONTEREY_HOOKING">>config.mak
|
||||
fi
|
||||
if ismac64 && [ "$fat_binary" = 1 ] ; then
|
||||
echo "Configuring a fat binary for i386 and x86_64"
|
||||
echo "MAC_CFLAGS+=-arch i386 -arch x86_64">>config.mak
|
||||
echo "FAT_LDFLAGS=-arch i386 -arch x86_64">>config.mak
|
||||
echo "FAT_BIN_LDFLAGS=-arch i386 -arch x86_64">>config.mak
|
||||
fi
|
||||
if [ "$fat_binary_m1" = 1 ] ; then
|
||||
echo "Configuring a fat binary for arm64[e] and x86_64"
|
||||
echo "MAC_CFLAGS+=-arch arm64 -arch arm64e -arch x86_64">>config.mak
|
||||
echo "FAT_LDFLAGS=-arch arm64 -arch arm64e -arch x86_64">>config.mak
|
||||
echo "FAT_BIN_LDFLAGS=-arch arm64 -arch x86_64">>config.mak
|
||||
fi
|
||||
if [ "$fat_binary_m2" = 1 ] ; then
|
||||
echo "Configuring a fat binary for arm64[e] and x86_64"
|
||||
echo "MAC_CFLAGS+=-arch arm64 -arch arm64e -arch x86_64">>config.mak
|
||||
echo "FAT_LDFLAGS=-arch arm64 -arch arm64e -arch x86_64">>config.mak
|
||||
echo "FAT_BIN_LDFLAGS=-arch arm64 -arch arm64e -arch x86_64">>config.mak
|
||||
fi
|
||||
echo LD_SET_SONAME=-Wl,-install_name,>>config.mak
|
||||
elif isbsd ; then
|
||||
echo LIBDL=>>config.mak
|
||||
echo "CFLAGS+=-DIS_BSD">>config.mak
|
||||
isopenbsd && echo "CFLAGS+=-DIS_OPENBSD">>config.mak
|
||||
make_cmd=gmake
|
||||
elif issolaris; then
|
||||
echo "CFLAGS+=-DIS_SOLARIS -D__EXTENSIONS__" >> config.mak
|
||||
echo "SOCKET_LIBS=-lsocket -lnsl" >> config.mak
|
||||
elif ishaiku ; then
|
||||
echo LIBDL=>>config.mak
|
||||
echo "CFLAGS+=-DIS_HAIKU" >> config.mak
|
||||
fi
|
||||
|
||||
echo "Done, now run $make_cmd && $make_cmd install"
|
||||
if [ "$fat_binary_m2" = 1 ] ; then
|
||||
echo "Don't forget to run csrutil disable and sudo nvram boot-args=-arm64e_preview_abi"
|
||||
fi
|
||||
|
|
|
@ -1,11 +0,0 @@
|
|||
### config.mak template for proxychains
|
||||
#######################################
|
||||
|
||||
# just copy into proxychains root dir and adapt to your needs.
|
||||
|
||||
prefix = /usr/local/
|
||||
libdir = $(prefix)/lib
|
||||
|
||||
exec_prefix = /usr/local
|
||||
bindir = $(exec_prefix)/bin
|
||||
|
|
@ -1,3 +1,8 @@
|
|||
#undef _GNU_SOURCE
|
||||
#define _GNU_SOURCE
|
||||
#undef _POSIX_C_SOURCE
|
||||
#define _DARWIN_C_SOURCE
|
||||
#include <limits.h>
|
||||
#include <pthread.h>
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
|
@ -9,13 +14,13 @@
|
|||
#include <stdint.h>
|
||||
#include <stddef.h>
|
||||
#include <errno.h>
|
||||
#include <sys/mman.h>
|
||||
#include "allocator_thread.h"
|
||||
#include "shm.h"
|
||||
#include "debug.h"
|
||||
#include "ip_type.h"
|
||||
#include "mutex.h"
|
||||
#include "hash.h"
|
||||
#include "stringdump.h"
|
||||
#include "remotedns.h"
|
||||
|
||||
/* stuff for our internal translation table */
|
||||
|
||||
|
@ -30,20 +35,25 @@ typedef struct {
|
|||
string_hash_tuple** list;
|
||||
} internal_ip_lookup_table;
|
||||
|
||||
pthread_mutex_t internal_ips_lock;
|
||||
internal_ip_lookup_table *internal_ips = NULL;
|
||||
internal_ip_lookup_table internal_ips_buf;
|
||||
static void *dumpstring(char* s, size_t len) {
|
||||
char* p = malloc(len);
|
||||
if(p) memcpy(p, s, len);
|
||||
return p;
|
||||
}
|
||||
|
||||
uint32_t index_from_internal_ip(ip_type internalip) {
|
||||
static pthread_mutex_t *internal_ips_lock;
|
||||
static internal_ip_lookup_table *internal_ips;
|
||||
|
||||
uint32_t index_from_internal_ip(ip_type4 internalip) {
|
||||
PFUNC();
|
||||
ip_type tmp = internalip;
|
||||
ip_type4 tmp = internalip;
|
||||
uint32_t ret;
|
||||
ret = tmp.octet[3] + (tmp.octet[2] << 8) + (tmp.octet[1] << 16);
|
||||
ret -= 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
char *string_from_internal_ip(ip_type internalip) {
|
||||
char *string_from_internal_ip(ip_type4 internalip) {
|
||||
PFUNC();
|
||||
char *res = NULL;
|
||||
uint32_t index = index_from_internal_ip(internalip);
|
||||
|
@ -53,11 +63,11 @@ char *string_from_internal_ip(ip_type internalip) {
|
|||
}
|
||||
|
||||
extern unsigned int remote_dns_subnet;
|
||||
ip_type make_internal_ip(uint32_t index) {
|
||||
ip_type ret;
|
||||
ip_type4 make_internal_ip(uint32_t index) {
|
||||
ip_type4 ret;
|
||||
index++; // so we can start at .0.0.1
|
||||
if(index > 0xFFFFFF)
|
||||
return ip_type_invalid;
|
||||
return IPT4_INVALID;
|
||||
ret.octet[0] = remote_dns_subnet & 0xFF;
|
||||
ret.octet[1] = (index & 0xFF0000) >> 16;
|
||||
ret.octet[2] = (index & 0xFF00) >> 8;
|
||||
|
@ -65,10 +75,10 @@ ip_type make_internal_ip(uint32_t index) {
|
|||
return ret;
|
||||
}
|
||||
|
||||
static ip_type ip_from_internal_list(char* name, size_t len) {
|
||||
static ip_type4 ip_from_internal_list(char* name, size_t len) {
|
||||
uint32_t hash = dalias_hash((char *) name);
|
||||
size_t i;
|
||||
ip_type res;
|
||||
ip_type4 res;
|
||||
void* new_mem;
|
||||
// see if we already have this dns entry saved.
|
||||
if(internal_ips->counter) {
|
||||
|
@ -95,7 +105,7 @@ static ip_type ip_from_internal_list(char* name, size_t len) {
|
|||
}
|
||||
|
||||
res = make_internal_ip(internal_ips->counter);
|
||||
if(res.as_int == ip_type_invalid.as_int)
|
||||
if(res.as_int == IPT4_INVALID.as_int)
|
||||
goto err_plus_unlock;
|
||||
|
||||
string_hash_tuple tmp = { 0 };
|
||||
|
@ -108,7 +118,7 @@ static ip_type ip_from_internal_list(char* name, size_t len) {
|
|||
internal_ips->list[internal_ips->counter] = new_mem;
|
||||
internal_ips->list[internal_ips->counter]->hash = hash;
|
||||
|
||||
new_mem = dumpstring((char*) name, len + 1);
|
||||
new_mem = dumpstring((char*) name, len);
|
||||
|
||||
if(!new_mem) {
|
||||
internal_ips->list[internal_ips->counter] = 0;
|
||||
|
@ -124,30 +134,18 @@ static ip_type ip_from_internal_list(char* name, size_t len) {
|
|||
err_plus_unlock:
|
||||
|
||||
PDEBUG("return err\n");
|
||||
return ip_type_invalid;
|
||||
return IPT4_INVALID;
|
||||
}
|
||||
|
||||
/* stuff for communication with the allocator thread */
|
||||
|
||||
enum at_msgtype {
|
||||
ATM_GETIP,
|
||||
ATM_GETNAME,
|
||||
ATM_EXIT,
|
||||
};
|
||||
|
||||
enum at_direction {
|
||||
ATD_SERVER = 0,
|
||||
ATD_CLIENT,
|
||||
ATD_MAX,
|
||||
};
|
||||
|
||||
struct at_msghdr {
|
||||
enum at_msgtype msgtype;
|
||||
size_t datalen;
|
||||
};
|
||||
|
||||
static pthread_t allocator_thread;
|
||||
static pthread_attr_t allocator_thread_attr;
|
||||
int req_pipefd[2];
|
||||
int resp_pipefd[2];
|
||||
|
||||
|
@ -172,25 +170,62 @@ static int wait_data(int readfd) {
|
|||
return 1;
|
||||
}
|
||||
|
||||
static int sendmessage(enum at_direction dir, struct at_msghdr *hdr, void* data) {
|
||||
static int* destfd[ATD_MAX] = { [ATD_SERVER] = &req_pipefd[1], [ATD_CLIENT] = &resp_pipefd[1] };
|
||||
int ret = write(*destfd[dir], hdr, sizeof *hdr) == sizeof *hdr;
|
||||
if(ret && hdr->datalen) {
|
||||
assert(hdr->datalen <= MSG_LEN_MAX);
|
||||
ret = write(*destfd[dir], data, hdr->datalen) == hdr->datalen;
|
||||
static int trywrite(int fd, void* buf, size_t bytes) {
|
||||
ssize_t ret;
|
||||
unsigned char *out = buf;
|
||||
again:
|
||||
ret = write(fd, out, bytes);
|
||||
switch(ret) {
|
||||
case -1:
|
||||
if(errno == EINTR) goto again;
|
||||
case 0:
|
||||
return 0;
|
||||
default:
|
||||
if(ret == bytes || !bytes) return 1;
|
||||
out += ret;
|
||||
bytes -= ret;
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
|
||||
static int sendmessage(enum at_direction dir, struct at_msg *msg) {
|
||||
static int* destfd[ATD_MAX] = { [ATD_SERVER] = &req_pipefd[1], [ATD_CLIENT] = &resp_pipefd[1] };
|
||||
assert(msg->h.datalen <= MSG_LEN_MAX);
|
||||
int ret = trywrite(*destfd[dir], msg, sizeof (msg->h)+msg->h.datalen);
|
||||
assert(msg->h.datalen <= MSG_LEN_MAX);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int getmessage(enum at_direction dir, struct at_msghdr *hdr, void* data) {
|
||||
static int tryread(int fd, void* buf, size_t bytes) {
|
||||
ssize_t ret;
|
||||
unsigned char *out = buf;
|
||||
again:
|
||||
ret = read(fd, out, bytes);
|
||||
switch(ret) {
|
||||
case -1:
|
||||
if(errno == EINTR) goto again;
|
||||
case 0:
|
||||
return 0;
|
||||
default:
|
||||
if(ret == bytes || !bytes) return 1;
|
||||
out += ret;
|
||||
bytes -= ret;
|
||||
goto again;
|
||||
}
|
||||
}
|
||||
static int readmsg(int fd, struct at_msg *msg) {
|
||||
int ret = tryread(fd, msg, sizeof(msg->h));
|
||||
if(ret != 1) return ret;
|
||||
return tryread(fd, &msg->m, msg->h.datalen);
|
||||
}
|
||||
|
||||
static int getmessage(enum at_direction dir, struct at_msg *msg) {
|
||||
static int* readfd[ATD_MAX] = { [ATD_SERVER] = &req_pipefd[0], [ATD_CLIENT] = &resp_pipefd[0] };
|
||||
int ret;
|
||||
ssize_t ret;
|
||||
if((ret = wait_data(*readfd[dir]))) {
|
||||
ret = read(*readfd[dir], hdr, sizeof *hdr) == sizeof(*hdr);
|
||||
assert(hdr->datalen <= MSG_LEN_MAX);
|
||||
if(ret && hdr->datalen) {
|
||||
ret = read(*readfd[dir], data, hdr->datalen) == hdr->datalen;
|
||||
}
|
||||
if(!readmsg(*readfd[dir], msg))
|
||||
return 0;
|
||||
assert(msg->h.datalen <= MSG_LEN_MAX);
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
@ -198,26 +233,24 @@ static int getmessage(enum at_direction dir, struct at_msghdr *hdr, void* data)
|
|||
static void* threadfunc(void* x) {
|
||||
(void) x;
|
||||
int ret;
|
||||
struct at_msghdr msg;
|
||||
union {
|
||||
char host[MSG_LEN_MAX];
|
||||
ip_type ip;
|
||||
} readbuf;
|
||||
while((ret = getmessage(ATD_SERVER, &msg, &readbuf))) {
|
||||
switch(msg.msgtype) {
|
||||
struct at_msg msg;
|
||||
while((ret = getmessage(ATD_SERVER, &msg))) {
|
||||
switch(msg.h.msgtype) {
|
||||
case ATM_GETIP:
|
||||
/* client wants an ip for a DNS name. iterate our list and check if we have an existing entry.
|
||||
* if not, create a new one. */
|
||||
readbuf.ip = ip_from_internal_list(readbuf.host, msg.datalen - 1);
|
||||
msg.datalen = sizeof(ip_type);
|
||||
msg.m.ip = ip_from_internal_list(msg.m.host, msg.h.datalen);
|
||||
msg.h.datalen = sizeof(ip_type4);
|
||||
break;
|
||||
case ATM_GETNAME: {
|
||||
char *host = string_from_internal_ip(readbuf.ip);
|
||||
char *host = string_from_internal_ip(msg.m.ip);
|
||||
if(host) {
|
||||
size_t l = strlen(host);
|
||||
assert(l < MSG_LEN_MAX);
|
||||
memcpy(readbuf.host, host, l + 1);
|
||||
msg.datalen = l + 1;
|
||||
assert(l+1 < MSG_LEN_MAX);
|
||||
memcpy(msg.m.host, host, l + 1);
|
||||
msg.h.datalen = l + 1;
|
||||
} else {
|
||||
msg.h.datalen = 0;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
@ -226,60 +259,92 @@ static void* threadfunc(void* x) {
|
|||
default:
|
||||
abort();
|
||||
}
|
||||
ret = sendmessage(ATD_CLIENT, &msg, &readbuf);
|
||||
ret = sendmessage(ATD_CLIENT, &msg);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* API to access the internal ip mapping */
|
||||
|
||||
ip_type at_get_ip_for_host(char* host, size_t len) {
|
||||
ip_type readbuf;
|
||||
MUTEX_LOCK(&internal_ips_lock);
|
||||
ip_type4 at_get_ip_for_host(char* host, size_t len) {
|
||||
ip_type4 readbuf;
|
||||
MUTEX_LOCK(internal_ips_lock);
|
||||
if(len > MSG_LEN_MAX) goto inv;
|
||||
struct at_msghdr msg = {.msgtype = ATM_GETIP, .datalen = len + 1 };
|
||||
if(sendmessage(ATD_SERVER, &msg, host) &&
|
||||
getmessage(ATD_CLIENT, &msg, &readbuf));
|
||||
struct at_msg msg = {.h.msgtype = ATM_GETIP, .h.datalen = len + 1 };
|
||||
memcpy(msg.m.host, host, len+1);
|
||||
if(sendmessage(ATD_SERVER, &msg) &&
|
||||
getmessage(ATD_CLIENT, &msg)) readbuf = msg.m.ip;
|
||||
else {
|
||||
inv:
|
||||
readbuf = ip_type_invalid;
|
||||
readbuf = IPT4_INVALID;
|
||||
}
|
||||
MUTEX_UNLOCK(&internal_ips_lock);
|
||||
assert(msg.h.msgtype == ATM_GETIP);
|
||||
MUTEX_UNLOCK(internal_ips_lock);
|
||||
return readbuf;
|
||||
}
|
||||
|
||||
size_t at_get_host_for_ip(ip_type ip, char* readbuf) {
|
||||
struct at_msghdr msg = {.msgtype = ATM_GETNAME, .datalen = sizeof(ip_type) };
|
||||
size_t at_get_host_for_ip(ip_type4 ip, char* readbuf) {
|
||||
struct at_msg msg = {.h.msgtype = ATM_GETNAME, .h.datalen = sizeof(ip_type4), .m.ip = ip };
|
||||
size_t res = 0;
|
||||
MUTEX_LOCK(&internal_ips_lock);
|
||||
if(sendmessage(ATD_SERVER, &msg, &ip) && getmessage(ATD_CLIENT, &msg, readbuf)) {
|
||||
if((ptrdiff_t) msg.datalen <= 0) res = 0;
|
||||
else res = msg.datalen - 1;
|
||||
MUTEX_LOCK(internal_ips_lock);
|
||||
if(sendmessage(ATD_SERVER, &msg) && getmessage(ATD_CLIENT, &msg)) {
|
||||
if((int16_t) msg.h.datalen <= 0) res = 0;
|
||||
else {
|
||||
memcpy(readbuf, msg.m.host, msg.h.datalen);
|
||||
res = msg.h.datalen - 1;
|
||||
}
|
||||
}
|
||||
MUTEX_UNLOCK(&internal_ips_lock);
|
||||
assert(msg.h.msgtype == ATM_GETNAME);
|
||||
MUTEX_UNLOCK(internal_ips_lock);
|
||||
return res;
|
||||
}
|
||||
|
||||
|
||||
static void initpipe(int* fds) {
|
||||
if(pipe(fds) == -1) {
|
||||
int retval;
|
||||
|
||||
#ifdef HAVE_PIPE2
|
||||
retval = pipe2(fds, O_CLOEXEC);
|
||||
#else
|
||||
retval = pipe(fds);
|
||||
if(retval == 0) {
|
||||
fcntl(fds[0], F_SETFD, FD_CLOEXEC);
|
||||
fcntl(fds[1], F_SETFD, FD_CLOEXEC);
|
||||
}
|
||||
#endif
|
||||
if(retval == -1) {
|
||||
perror("pipe");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
||||
#ifndef MAX
|
||||
#define MAX(x, y) ((x) > (y) ? (x) : (y))
|
||||
#endif
|
||||
|
||||
#if !defined(PTHREAD_STACK_MIN) || defined(__APPLE__)
|
||||
/* MAC says its min is 8KB, but then crashes in our face. thx hunkOLard */
|
||||
#define PTHREAD_STACK_MIN 64*1024
|
||||
#endif
|
||||
|
||||
/* initialize with pointers to shared memory. these will
|
||||
* be used to place responses and arguments */
|
||||
void at_init(void) {
|
||||
PFUNC();
|
||||
MUTEX_INIT(&internal_ips_lock);
|
||||
internal_ips = &internal_ips_buf;
|
||||
void *shm = mmap(0, 4096, PROT_WRITE|PROT_READ, MAP_ANON|MAP_SHARED, -1, 0);
|
||||
assert(shm);
|
||||
internal_ips_lock = shm;
|
||||
internal_ips = (void*)((char*)shm + 2048);
|
||||
|
||||
MUTEX_INIT(internal_ips_lock);
|
||||
memset(internal_ips, 0, sizeof *internal_ips);
|
||||
initpipe(req_pipefd);
|
||||
initpipe(resp_pipefd);
|
||||
pthread_attr_t allocator_thread_attr;
|
||||
pthread_attr_init(&allocator_thread_attr);
|
||||
pthread_attr_setstacksize(&allocator_thread_attr, 16 * 1024);
|
||||
pthread_attr_setstacksize(&allocator_thread_attr, MAX(16 * 1024, PTHREAD_STACK_MIN));
|
||||
pthread_create(&allocator_thread, &allocator_thread_attr, threadfunc, 0);
|
||||
pthread_attr_destroy(&allocator_thread_attr);
|
||||
}
|
||||
|
||||
void at_close(void) {
|
||||
|
@ -291,6 +356,5 @@ void at_close(void) {
|
|||
close(req_pipefd[1]);
|
||||
close(resp_pipefd[0]);
|
||||
close(resp_pipefd[1]);
|
||||
pthread_attr_destroy(&allocator_thread_attr);
|
||||
MUTEX_DESTROY(&internal_ips_lock);
|
||||
MUTEX_DESTROY(internal_ips_lock);
|
||||
}
|
||||
|
|
|
@ -4,15 +4,13 @@
|
|||
#include <unistd.h>
|
||||
#include "ip_type.h"
|
||||
|
||||
#define MSG_LEN_MAX 256
|
||||
|
||||
extern int req_pipefd[2];
|
||||
extern int resp_pipefd[2];
|
||||
|
||||
void at_init(void);
|
||||
void at_close(void);
|
||||
size_t at_get_host_for_ip(ip_type ip, char* readbuf);
|
||||
ip_type at_get_ip_for_host(char* host, size_t len);
|
||||
size_t at_get_host_for_ip(ip_type4 ip, char* readbuf);
|
||||
ip_type4 at_get_ip_for_host(char* host, size_t len);
|
||||
|
||||
//RcB: DEP "allocator_thread.c"
|
||||
#endif
|
||||
|
|
34
src/common.c
34
src/common.c
|
@ -23,6 +23,33 @@ const char *proxy_state_strmap[] = {
|
|||
"busy",
|
||||
};
|
||||
|
||||
/* isnumericipv4() taken from libulz */
|
||||
int pc_isnumericipv4(const char* ipstring) {
|
||||
size_t x = 0, n = 0, d = 0;
|
||||
int wasdot = 0;
|
||||
while(1) {
|
||||
switch(ipstring[x]) {
|
||||
case 0: goto done;
|
||||
case '.':
|
||||
if(!n || wasdot) return 0;
|
||||
d++;
|
||||
wasdot = 1;
|
||||
break;
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9':
|
||||
n++;
|
||||
wasdot = 0;
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
x++;
|
||||
}
|
||||
done:
|
||||
if(d == 3 && n >= 4 && n <= 12) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
// stolen from libulz (C) rofl0r
|
||||
void pc_stringfromipv4(unsigned char *ip_buf_4_bytes, char *outbuf_16_bytes) {
|
||||
unsigned char *p;
|
||||
|
@ -79,6 +106,13 @@ char *get_config_path(char* default_path, char* pbuf, size_t bufsize) {
|
|||
if(check_path(path))
|
||||
goto have;
|
||||
|
||||
// priority 3b: ~/config/settings/proxychains.conf (for haiku)
|
||||
path = getenv("HOME");
|
||||
snprintf(pbuf, bufsize, "%s/config/settings/%s", path, PROXYCHAINS_CONF_FILE);
|
||||
path = pbuf;
|
||||
if(check_path(path))
|
||||
goto have;
|
||||
|
||||
// priority 4: $SYSCONFDIR/proxychains.conf
|
||||
path = SYSCONFDIR "/" PROXYCHAINS_CONF_FILE;
|
||||
if(check_path(path))
|
||||
|
|
|
@ -17,6 +17,7 @@ extern const char *proxy_state_strmap[];
|
|||
|
||||
char *get_config_path(char* default_path, char* pbuf, size_t bufsize);
|
||||
void pc_stringfromipv4(unsigned char *ip_buf_4_bytes, char *outbuf_16_bytes);
|
||||
int pc_isnumericipv4(const char* ipstring);
|
||||
|
||||
//RcB: DEP "common.c"
|
||||
#endif
|
||||
|
|
707
src/core.c
707
src/core.c
|
@ -37,8 +37,8 @@
|
|||
|
||||
#include "core.h"
|
||||
#include "common.h"
|
||||
#include "shm.h"
|
||||
#include "allocator_thread.h"
|
||||
#include "rdns.h"
|
||||
#include "mutex.h"
|
||||
|
||||
extern int tcp_read_time_out;
|
||||
extern int tcp_connect_time_out;
|
||||
|
@ -107,7 +107,7 @@ static void encode_base_64(char *src, char *dest, int max_len) {
|
|||
}
|
||||
|
||||
void proxychains_write_log(char *str, ...) {
|
||||
char buff[1024*20];
|
||||
char buff[1024*4];
|
||||
va_list arglist;
|
||||
if(!proxychains_quiet_mode) {
|
||||
va_start(arglist, str);
|
||||
|
@ -188,6 +188,7 @@ static int timed_connect(int sock, const struct sockaddr *addr, socklen_t len) {
|
|||
|
||||
|
||||
#define INVALID_INDEX 0xFFFFFFFFU
|
||||
#define BUFF_SIZE 1024 // used to read responses from proxies.
|
||||
static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, char *user, char *pass) {
|
||||
char *dns_name = NULL;
|
||||
char hostnamebuf[MSG_LEN_MAX];
|
||||
|
@ -199,8 +200,8 @@ static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, c
|
|||
// the range 224-255.* is reserved, and it won't go outside (unless the app does some other stuff with
|
||||
// the results returned from gethostbyname et al.)
|
||||
// the hardcoded number 224 can now be changed using the config option remote_dns_subnet to i.e. 127
|
||||
if(ip.octet[0] == remote_dns_subnet) {
|
||||
dns_len = at_get_host_for_ip(ip, hostnamebuf);
|
||||
if(!ip.is_v6 && proxychains_resolver >= DNSLF_RDNS_START && ip.addr.v4.octet[0] == remote_dns_subnet) {
|
||||
dns_len = rdns_get_host_for_ip(ip.addr.v4, hostnamebuf);
|
||||
if(!dns_len) goto err;
|
||||
else dns_name = hostnamebuf;
|
||||
}
|
||||
|
@ -217,209 +218,205 @@ static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, c
|
|||
|
||||
int len;
|
||||
unsigned char buff[BUFF_SIZE];
|
||||
char ip_buf[16];
|
||||
|
||||
//memset (buff, 0, sizeof(buff));
|
||||
char ip_buf[INET6_ADDRSTRLEN];
|
||||
int v6 = ip.is_v6;
|
||||
|
||||
switch (pt) {
|
||||
case RAW_TYPE: {
|
||||
return SUCCESS;
|
||||
}
|
||||
break;
|
||||
case HTTP_TYPE:{
|
||||
if(!dns_len) {
|
||||
pc_stringfromipv4(&ip.octet[0], ip_buf);
|
||||
dns_name = ip_buf;
|
||||
}
|
||||
|
||||
snprintf((char *) buff, sizeof(buff), "CONNECT %s:%d HTTP/1.0\r\n", dns_name,
|
||||
ntohs(port));
|
||||
|
||||
if(user[0]) {
|
||||
#define HTTP_AUTH_MAX ((0xFF * 2) + 1 + 1)
|
||||
// 2 * 0xff: username and pass, plus 1 for ':' and 1 for zero terminator.
|
||||
char src[HTTP_AUTH_MAX];
|
||||
char dst[(4 * HTTP_AUTH_MAX)];
|
||||
|
||||
memcpy(src, user, ulen);
|
||||
memcpy(src + ulen, ":", 1);
|
||||
memcpy(src + ulen + 1, pass, passlen);
|
||||
src[ulen + 1 + passlen] = 0;
|
||||
|
||||
encode_base_64(src, dst, sizeof(dst));
|
||||
strcat((char *) buff, "Proxy-Authorization: Basic ");
|
||||
strcat((char *) buff, dst);
|
||||
strcat((char *) buff, "\r\n\r\n");
|
||||
} else
|
||||
strcat((char *) buff, "\r\n");
|
||||
|
||||
len = strlen((char *) buff);
|
||||
|
||||
if(len != send(sock, buff, len, 0))
|
||||
if(!dns_len) {
|
||||
if(!inet_ntop(v6?AF_INET6:AF_INET,ip.addr.v6,ip_buf,sizeof ip_buf)) {
|
||||
proxychains_write_log(LOG_PREFIX "error: ip address conversion failed\n");
|
||||
goto err;
|
||||
|
||||
len = 0;
|
||||
// read header byte by byte.
|
||||
while(len < BUFF_SIZE) {
|
||||
if(1 == read_n_bytes(sock, (char *) (buff + len), 1))
|
||||
len++;
|
||||
else
|
||||
goto err;
|
||||
if(len > 4 &&
|
||||
buff[len - 1] == '\n' &&
|
||||
buff[len - 2] == '\r' && buff[len - 3] == '\n' && buff[len - 4] == '\r')
|
||||
break;
|
||||
}
|
||||
|
||||
// if not ok (200) or response greather than BUFF_SIZE return BLOCKED;
|
||||
if(len == BUFF_SIZE || !(buff[9] == '2' && buff[10] == '0' && buff[11] == '0')) {
|
||||
PDEBUG("HTTP proxy blocked: buff=\"%s\"\n", buff);
|
||||
return BLOCKED;
|
||||
}
|
||||
|
||||
return SUCCESS;
|
||||
dns_name = ip_buf;
|
||||
}
|
||||
break;
|
||||
#define HTTP_AUTH_MAX ((0xFF * 2) + 1 + 1) /* 2 * 0xff: username and pass, plus 1 for ':' and 1 for zero terminator. */
|
||||
char src[HTTP_AUTH_MAX];
|
||||
char dst[(4 * HTTP_AUTH_MAX)];
|
||||
if(ulen) {
|
||||
snprintf(src, sizeof(src), "%s:%s", user, pass);
|
||||
encode_base_64(src, dst, sizeof(dst));
|
||||
} else dst[0] = 0;
|
||||
|
||||
uint16_t hs_port = ntohs(port);
|
||||
len = snprintf((char *) buff, sizeof(buff),
|
||||
"CONNECT %s:%d HTTP/1.0\r\nHost: %s:%d\r\n%s%s%s\r\n",
|
||||
dns_name, hs_port,
|
||||
dns_name, hs_port,
|
||||
ulen ? "Proxy-Authorization: Basic " : dst,
|
||||
dst, ulen ? "\r\n" : dst);
|
||||
|
||||
if(len < 0 || len != send(sock, buff, len, 0))
|
||||
goto err;
|
||||
|
||||
len = 0;
|
||||
// read header byte by byte.
|
||||
while(len < BUFF_SIZE) {
|
||||
if(1 == read_n_bytes(sock, (char *) (buff + len), 1))
|
||||
len++;
|
||||
else
|
||||
goto err;
|
||||
if(len > 4 &&
|
||||
buff[len - 1] == '\n' &&
|
||||
buff[len - 2] == '\r' && buff[len - 3] == '\n' && buff[len - 4] == '\r')
|
||||
break;
|
||||
}
|
||||
|
||||
// if not ok (200) or response greather than BUFF_SIZE return BLOCKED;
|
||||
if(len == BUFF_SIZE || !(buff[9] == '2' && buff[10] == '0' && buff[11] == '0')) {
|
||||
PDEBUG("HTTP proxy blocked: buff=\"%s\"\n", buff);
|
||||
return BLOCKED;
|
||||
}
|
||||
|
||||
return SUCCESS;
|
||||
}
|
||||
break;
|
||||
case SOCKS4_TYPE:{
|
||||
buff[0] = 4; // socks version
|
||||
buff[1] = 1; // connect command
|
||||
memcpy(&buff[2], &port, 2); // dest port
|
||||
if(dns_len) {
|
||||
ip.octet[0] = 0;
|
||||
ip.octet[1] = 0;
|
||||
ip.octet[2] = 0;
|
||||
ip.octet[3] = 1;
|
||||
}
|
||||
memcpy(&buff[4], &ip, 4); // dest host
|
||||
len = ulen + 1; // username
|
||||
if(len > 1)
|
||||
memcpy(&buff[8], user, len);
|
||||
else {
|
||||
buff[8] = 0;
|
||||
}
|
||||
|
||||
// do socksv4a dns resolution on the server
|
||||
if(dns_len) {
|
||||
memcpy(&buff[8 + len], dns_name, dns_len + 1);
|
||||
len += dns_len + 1;
|
||||
}
|
||||
|
||||
if((len + 8) != write_n_bytes(sock, (char *) buff, (8 + len)))
|
||||
goto err;
|
||||
|
||||
if(8 != read_n_bytes(sock, (char *) buff, 8))
|
||||
goto err;
|
||||
|
||||
if(buff[0] != 0 || buff[1] != 90)
|
||||
return BLOCKED;
|
||||
|
||||
return SUCCESS;
|
||||
if(v6) {
|
||||
proxychains_write_log(LOG_PREFIX "error: SOCKS4 doesn't support ipv6 addresses\n");
|
||||
goto err;
|
||||
}
|
||||
break;
|
||||
buff[0] = 4; // socks version
|
||||
buff[1] = 1; // connect command
|
||||
memcpy(&buff[2], &port, 2); // dest port
|
||||
if(dns_len) {
|
||||
ip.addr.v4.octet[0] = 0;
|
||||
ip.addr.v4.octet[1] = 0;
|
||||
ip.addr.v4.octet[2] = 0;
|
||||
ip.addr.v4.octet[3] = 1;
|
||||
}
|
||||
memcpy(&buff[4], &ip.addr.v4, 4); // dest host
|
||||
len = ulen + 1; // username
|
||||
if(len > 1)
|
||||
memcpy(&buff[8], user, len);
|
||||
else {
|
||||
buff[8] = 0;
|
||||
}
|
||||
|
||||
// do socksv4a dns resolution on the server
|
||||
if(dns_len) {
|
||||
memcpy(&buff[8 + len], dns_name, dns_len + 1);
|
||||
len += dns_len + 1;
|
||||
}
|
||||
|
||||
if((len + 8) != write_n_bytes(sock, (char *) buff, (8 + len)))
|
||||
goto err;
|
||||
|
||||
if(8 != read_n_bytes(sock, (char *) buff, 8))
|
||||
goto err;
|
||||
|
||||
if(buff[0] != 0 || buff[1] != 90)
|
||||
return BLOCKED;
|
||||
|
||||
return SUCCESS;
|
||||
}
|
||||
break;
|
||||
case SOCKS5_TYPE:{
|
||||
if(user) {
|
||||
buff[0] = 5; //version
|
||||
buff[1] = 2; //nomber of methods
|
||||
buff[2] = 0; // no auth method
|
||||
buff[3] = 2; /// auth method -> username / password
|
||||
if(4 != write_n_bytes(sock, (char *) buff, 4))
|
||||
goto err;
|
||||
} else {
|
||||
buff[0] = 5; //version
|
||||
buff[1] = 1; //nomber of methods
|
||||
buff[2] = 0; // no auth method
|
||||
if(3 != write_n_bytes(sock, (char *) buff, 3))
|
||||
goto err;
|
||||
}
|
||||
int n_methods = ulen ? 2 : 1;
|
||||
buff[0] = 5; // version
|
||||
buff[1] = n_methods ; // number of methods
|
||||
buff[2] = 0; // no auth method
|
||||
if(ulen) buff[3] = 2; /// auth method -> username / password
|
||||
if(2+n_methods != write_n_bytes(sock, (char *) buff, 2+n_methods))
|
||||
goto err;
|
||||
|
||||
if(2 != read_n_bytes(sock, (char *) buff, 2))
|
||||
if(2 != read_n_bytes(sock, (char *) buff, 2))
|
||||
goto err;
|
||||
|
||||
if(buff[0] != 5 || (buff[1] != 0 && buff[1] != 2)) {
|
||||
if(buff[0] == 5 && buff[1] == 0xFF)
|
||||
return BLOCKED;
|
||||
else
|
||||
goto err;
|
||||
|
||||
if(buff[0] != 5 || (buff[1] != 0 && buff[1] != 2)) {
|
||||
if(buff[0] == 5 && buff[1] == 0xFF)
|
||||
return BLOCKED;
|
||||
else
|
||||
goto err;
|
||||
}
|
||||
|
||||
if(buff[1] == 2) {
|
||||
// authentication
|
||||
char in[2];
|
||||
char out[515];
|
||||
char *cur = out;
|
||||
size_t c;
|
||||
*cur++ = 1; // version
|
||||
c = ulen & 0xFF;
|
||||
*cur++ = c;
|
||||
memcpy(cur, user, c);
|
||||
cur += c;
|
||||
c = passlen & 0xFF;
|
||||
*cur++ = c;
|
||||
memcpy(cur, pass, c);
|
||||
cur += c;
|
||||
|
||||
if((cur - out) != write_n_bytes(sock, out, cur - out))
|
||||
goto err;
|
||||
|
||||
|
||||
if(2 != read_n_bytes(sock, in, 2))
|
||||
goto err;
|
||||
if(in[0] != 1 || in[1] != 0) {
|
||||
if(in[0] != 1)
|
||||
goto err;
|
||||
else
|
||||
return BLOCKED;
|
||||
}
|
||||
}
|
||||
int buff_iter = 0;
|
||||
buff[buff_iter++] = 5; // version
|
||||
buff[buff_iter++] = 1; // connect
|
||||
buff[buff_iter++] = 0; // reserved
|
||||
|
||||
if(!dns_len) {
|
||||
buff[buff_iter++] = 1; // ip v4
|
||||
memcpy(buff + buff_iter, &ip, 4); // dest host
|
||||
buff_iter += 4;
|
||||
} else {
|
||||
buff[buff_iter++] = 3; //dns
|
||||
buff[buff_iter++] = dns_len & 0xFF;
|
||||
memcpy(buff + buff_iter, dns_name, dns_len);
|
||||
buff_iter += dns_len;
|
||||
}
|
||||
|
||||
memcpy(buff + buff_iter, &port, 2); // dest port
|
||||
buff_iter += 2;
|
||||
|
||||
|
||||
if(buff_iter != write_n_bytes(sock, (char *) buff, buff_iter))
|
||||
goto err;
|
||||
|
||||
if(4 != read_n_bytes(sock, (char *) buff, 4))
|
||||
goto err;
|
||||
|
||||
if(buff[0] != 5 || buff[1] != 0)
|
||||
goto err;
|
||||
|
||||
switch (buff[3]) {
|
||||
|
||||
case 1:
|
||||
len = 4;
|
||||
break;
|
||||
case 4:
|
||||
len = 16;
|
||||
break;
|
||||
case 3:
|
||||
len = 0;
|
||||
if(1 != read_n_bytes(sock, (char *) &len, 1))
|
||||
goto err;
|
||||
break;
|
||||
default:
|
||||
goto err;
|
||||
}
|
||||
|
||||
if(len + 2 != read_n_bytes(sock, (char *) buff, len + 2))
|
||||
goto err;
|
||||
|
||||
return SUCCESS;
|
||||
}
|
||||
break;
|
||||
|
||||
if(buff[1] == 2) {
|
||||
// authentication
|
||||
char in[2];
|
||||
char out[515];
|
||||
char *cur = out;
|
||||
size_t c;
|
||||
*cur++ = 1; // version
|
||||
c = ulen & 0xFF;
|
||||
*cur++ = c;
|
||||
memcpy(cur, user, c);
|
||||
cur += c;
|
||||
c = passlen & 0xFF;
|
||||
*cur++ = c;
|
||||
memcpy(cur, pass, c);
|
||||
cur += c;
|
||||
|
||||
if((cur - out) != write_n_bytes(sock, out, cur - out))
|
||||
goto err;
|
||||
|
||||
|
||||
if(2 != read_n_bytes(sock, in, 2))
|
||||
goto err;
|
||||
/* according to RFC 1929 the version field for the user/pass auth sub-
|
||||
negotiation should be 1, which is kinda counter-intuitive, so there
|
||||
are some socks5 proxies that return 5 instead. other programs like
|
||||
curl work fine when the version is 5, so let's do the same and accept
|
||||
either of them. */
|
||||
if(!(in[0] == 5 || in[0] == 1))
|
||||
goto err;
|
||||
if(in[1] != 0)
|
||||
return BLOCKED;
|
||||
}
|
||||
int buff_iter = 0;
|
||||
buff[buff_iter++] = 5; // version
|
||||
buff[buff_iter++] = 1; // connect
|
||||
buff[buff_iter++] = 0; // reserved
|
||||
|
||||
if(!dns_len) {
|
||||
buff[buff_iter++] = v6 ? 4 : 1; // ip v4/v6
|
||||
memcpy(buff + buff_iter, ip.addr.v6, v6?16:4); // dest host
|
||||
buff_iter += v6?16:4;
|
||||
} else {
|
||||
buff[buff_iter++] = 3; //dns
|
||||
buff[buff_iter++] = dns_len & 0xFF;
|
||||
memcpy(buff + buff_iter, dns_name, dns_len);
|
||||
buff_iter += dns_len;
|
||||
}
|
||||
|
||||
memcpy(buff + buff_iter, &port, 2); // dest port
|
||||
buff_iter += 2;
|
||||
|
||||
|
||||
if(buff_iter != write_n_bytes(sock, (char *) buff, buff_iter))
|
||||
goto err;
|
||||
|
||||
if(4 != read_n_bytes(sock, (char *) buff, 4))
|
||||
goto err;
|
||||
|
||||
if(buff[0] != 5 || buff[1] != 0)
|
||||
goto err;
|
||||
|
||||
switch (buff[3]) {
|
||||
case 1:
|
||||
len = 4;
|
||||
break;
|
||||
case 4:
|
||||
len = 16;
|
||||
break;
|
||||
case 3:
|
||||
len = 0;
|
||||
if(1 != read_n_bytes(sock, (char *) &len, 1))
|
||||
goto err;
|
||||
break;
|
||||
default:
|
||||
goto err;
|
||||
}
|
||||
|
||||
if(len + 2 != read_n_bytes(sock, (char *) buff, len + 2))
|
||||
goto err;
|
||||
|
||||
return SUCCESS;
|
||||
}
|
||||
break;
|
||||
}
|
||||
|
||||
err:
|
||||
|
@ -433,22 +430,30 @@ static int tunnel_to(int sock, ip_type ip, unsigned short port, proxy_type pt, c
|
|||
#define RRT "Round Robin chain"
|
||||
|
||||
static int start_chain(int *fd, proxy_data * pd, char *begin_mark) {
|
||||
struct sockaddr_in addr;
|
||||
char ip_buf[16];
|
||||
int v6 = pd->ip.is_v6;
|
||||
|
||||
*fd = socket(PF_INET, SOCK_STREAM, 0);
|
||||
*fd = socket(v6?PF_INET6:PF_INET, SOCK_STREAM, 0);
|
||||
if(*fd == -1)
|
||||
goto error;
|
||||
|
||||
pc_stringfromipv4(&pd->ip.octet[0], ip_buf);
|
||||
char ip_buf[INET6_ADDRSTRLEN];
|
||||
if(!inet_ntop(v6?AF_INET6:AF_INET,pd->ip.addr.v6,ip_buf,sizeof ip_buf))
|
||||
goto error;
|
||||
|
||||
proxychains_write_log(LOG_PREFIX "%s " TP " %s:%d ",
|
||||
begin_mark, ip_buf, htons(pd->port));
|
||||
pd->ps = PLAY_STATE;
|
||||
memset(&addr, 0, sizeof(addr));
|
||||
addr.sin_family = AF_INET;
|
||||
addr.sin_addr.s_addr = (in_addr_t) pd->ip.as_int;
|
||||
addr.sin_port = pd->port;
|
||||
if(timed_connect(*fd, (struct sockaddr *) &addr, sizeof(addr))) {
|
||||
struct sockaddr_in addr = {
|
||||
.sin_family = AF_INET,
|
||||
.sin_port = pd->port,
|
||||
.sin_addr.s_addr = (in_addr_t) pd->ip.addr.v4.as_int
|
||||
};
|
||||
struct sockaddr_in6 addr6 = {
|
||||
.sin6_family = AF_INET6,
|
||||
.sin6_port = pd->port,
|
||||
};
|
||||
if(v6) memcpy(&addr6.sin6_addr.s6_addr, pd->ip.addr.v6, 16);
|
||||
if(timed_connect(*fd, (struct sockaddr *) (v6?(void*)&addr6:(void*)&addr), v6?sizeof(addr6):sizeof(addr))) {
|
||||
pd->ps = DOWN_STATE;
|
||||
goto error1;
|
||||
}
|
||||
|
@ -457,8 +462,10 @@ static int start_chain(int *fd, proxy_data * pd, char *begin_mark) {
|
|||
error1:
|
||||
proxychains_write_log(TP " timeout\n");
|
||||
error:
|
||||
if(*fd != -1)
|
||||
if(*fd != -1) {
|
||||
close(*fd);
|
||||
*fd = -1;
|
||||
}
|
||||
return SOCKET_ERROR;
|
||||
}
|
||||
|
||||
|
@ -470,7 +477,7 @@ static proxy_data *select_proxy(select_type how, proxy_data * pd, unsigned int p
|
|||
case RANDOMLY:
|
||||
do {
|
||||
k++;
|
||||
i = 0 + (unsigned int) (proxy_count * 1.0 * rand() / (RAND_MAX + 1.0));
|
||||
i = rand() % proxy_count;
|
||||
} while(pd[i].ps != PLAY_STATE && k < proxy_count * 100);
|
||||
break;
|
||||
case FIFOLY:
|
||||
|
@ -515,41 +522,50 @@ static unsigned int calc_alive(proxy_data * pd, unsigned int proxy_count) {
|
|||
}
|
||||
|
||||
|
||||
static int chain_step(int ns, proxy_data * pfrom, proxy_data * pto) {
|
||||
static int chain_step(int *ns, proxy_data * pfrom, proxy_data * pto) {
|
||||
int retcode = -1;
|
||||
char *hostname;
|
||||
char *hostname, *errmsg = 0;
|
||||
char hostname_buf[MSG_LEN_MAX];
|
||||
char ip_buf[16];
|
||||
char ip_buf[INET6_ADDRSTRLEN];
|
||||
int v6 = pto->ip.is_v6;
|
||||
|
||||
PFUNC();
|
||||
|
||||
if(pto->ip.octet[0] == remote_dns_subnet) {
|
||||
if(!at_get_host_for_ip(pto->ip, hostname_buf)) goto usenumericip;
|
||||
if(!v6 && proxychains_resolver >= DNSLF_RDNS_START && pto->ip.addr.v4.octet[0] == remote_dns_subnet) {
|
||||
if(!rdns_get_host_for_ip(pto->ip.addr.v4, hostname_buf)) goto usenumericip;
|
||||
else hostname = hostname_buf;
|
||||
} else {
|
||||
usenumericip:
|
||||
pc_stringfromipv4(&pto->ip.octet[0], ip_buf);
|
||||
if(!inet_ntop(v6?AF_INET6:AF_INET,pto->ip.addr.v6,ip_buf,sizeof ip_buf)) {
|
||||
pto->ps = DOWN_STATE;
|
||||
errmsg = "<--ip conversion error!\n";
|
||||
retcode = SOCKET_ERROR;
|
||||
goto err;
|
||||
}
|
||||
hostname = ip_buf;
|
||||
}
|
||||
|
||||
proxychains_write_log(TP " %s:%d ", hostname, htons(pto->port));
|
||||
retcode = tunnel_to(ns, pto->ip, pto->port, pfrom->pt, pfrom->user, pfrom->pass);
|
||||
retcode = tunnel_to(*ns, pto->ip, pto->port, pfrom->pt, pfrom->user, pfrom->pass);
|
||||
switch (retcode) {
|
||||
case SUCCESS:
|
||||
pto->ps = BUSY_STATE;
|
||||
break;
|
||||
case BLOCKED:
|
||||
pto->ps = BLOCKED_STATE;
|
||||
proxychains_write_log("<--denied\n");
|
||||
close(ns);
|
||||
break;
|
||||
errmsg = "<--denied\n";
|
||||
goto err;
|
||||
case SOCKET_ERROR:
|
||||
pto->ps = DOWN_STATE;
|
||||
proxychains_write_log("<--socket error or timeout!\n");
|
||||
close(ns);
|
||||
break;
|
||||
errmsg = "<--socket error or timeout!\n";
|
||||
goto err;
|
||||
}
|
||||
return retcode;
|
||||
err:
|
||||
if(errmsg) proxychains_write_log(errmsg);
|
||||
if(*ns != -1) close(*ns);
|
||||
*ns = -1;
|
||||
return retcode;
|
||||
}
|
||||
|
||||
int connect_proxy_chain(int sock, ip_type target_ip,
|
||||
|
@ -562,8 +578,8 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
unsigned int offset = 0;
|
||||
unsigned int alive_count = 0;
|
||||
unsigned int curr_len = 0;
|
||||
unsigned int curr_pos = 0;
|
||||
unsigned int looped = 0; // went back to start of list in RR mode
|
||||
unsigned int rr_loop_max = 14;
|
||||
|
||||
p3 = &p4;
|
||||
|
||||
|
@ -585,7 +601,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
p2 = select_proxy(FIFOLY, pd, proxy_count, &offset);
|
||||
if(!p2)
|
||||
break;
|
||||
if(SUCCESS != chain_step(ns, p1, p2)) {
|
||||
if(SUCCESS != chain_step(&ns, p1, p2)) {
|
||||
PDEBUG("GOTO AGAIN 1\n");
|
||||
goto again;
|
||||
}
|
||||
|
@ -594,29 +610,33 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
//proxychains_write_log(TP);
|
||||
p3->ip = target_ip;
|
||||
p3->port = target_port;
|
||||
if(SUCCESS != chain_step(ns, p1, p3))
|
||||
if(SUCCESS != chain_step(&ns, p1, p3))
|
||||
goto error;
|
||||
break;
|
||||
|
||||
case ROUND_ROBIN_TYPE:
|
||||
alive_count = calc_alive(pd, proxy_count);
|
||||
curr_pos = offset = proxychains_proxy_offset;
|
||||
offset = proxychains_proxy_offset;
|
||||
if(alive_count < max_chain)
|
||||
goto error_more;
|
||||
PDEBUG("1:rr_offset = %d, curr_pos = %d\n", offset, curr_pos);
|
||||
PDEBUG("1:rr_offset = %d\n", offset);
|
||||
/* Check from current RR offset til end */
|
||||
for (;rc != SUCCESS;) {
|
||||
if (!(p1 = select_proxy(FIFOLY, pd, proxy_count, &offset))) {
|
||||
/* We've reached the end of the list, go to the start */
|
||||
offset = 0;
|
||||
looped++;
|
||||
continue;
|
||||
} else if (looped && rc > 0 && offset >= curr_pos) {
|
||||
PDEBUG("GOTO MORE PROXIES 0\n");
|
||||
/* We've gone back to the start and now past our starting position */
|
||||
proxychains_proxy_offset = 0;
|
||||
goto error_more;
|
||||
}
|
||||
if (looped > rr_loop_max) {
|
||||
proxychains_proxy_offset = 0;
|
||||
goto error_more;
|
||||
} else {
|
||||
PDEBUG("rr_type all proxies down, release all\n");
|
||||
release_all(pd, proxy_count);
|
||||
/* Each loop we wait 10ms more */
|
||||
usleep(10000 * looped);
|
||||
continue;
|
||||
}
|
||||
}
|
||||
PDEBUG("2:rr_offset = %d\n", offset);
|
||||
rc=start_chain(&ns, p1, RRT);
|
||||
}
|
||||
|
@ -628,7 +648,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
/* Try from the beginning to where we started */
|
||||
offset = 0;
|
||||
continue;
|
||||
} else if(SUCCESS != chain_step(ns, p1, p2)) {
|
||||
} else if(SUCCESS != chain_step(&ns, p1, p2)) {
|
||||
PDEBUG("GOTO AGAIN 1\n");
|
||||
goto again;
|
||||
} else
|
||||
|
@ -640,7 +660,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
p3->port = target_port;
|
||||
proxychains_proxy_offset = offset+1;
|
||||
PDEBUG("pd_offset = %d, curr_len = %d\n", proxychains_proxy_offset, curr_len);
|
||||
if(SUCCESS != chain_step(ns, p1, p3))
|
||||
if(SUCCESS != chain_step(&ns, p1, p3))
|
||||
goto error;
|
||||
break;
|
||||
|
||||
|
@ -658,7 +678,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
while(offset < proxy_count) {
|
||||
if(!(p2 = select_proxy(FIFOLY, pd, proxy_count, &offset)))
|
||||
break;
|
||||
if(SUCCESS != chain_step(ns, p1, p2)) {
|
||||
if(SUCCESS != chain_step(&ns, p1, p2)) {
|
||||
PDEBUG("chain_step failed\n");
|
||||
goto error_strict;
|
||||
}
|
||||
|
@ -667,7 +687,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
//proxychains_write_log(TP);
|
||||
p3->ip = target_ip;
|
||||
p3->port = target_port;
|
||||
if(SUCCESS != chain_step(ns, p1, p3))
|
||||
if(SUCCESS != chain_step(&ns, p1, p3))
|
||||
goto error;
|
||||
break;
|
||||
|
||||
|
@ -683,7 +703,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
while(++curr_len < max_chain) {
|
||||
if(!(p2 = select_proxy(RANDOMLY, pd, proxy_count, &offset)))
|
||||
goto error_more;
|
||||
if(SUCCESS != chain_step(ns, p1, p2)) {
|
||||
if(SUCCESS != chain_step(&ns, p1, p2)) {
|
||||
PDEBUG("GOTO AGAIN 2\n");
|
||||
goto again;
|
||||
}
|
||||
|
@ -692,7 +712,7 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
//proxychains_write_log(TP);
|
||||
p3->ip = target_ip;
|
||||
p3->port = target_port;
|
||||
if(SUCCESS != chain_step(ns, p1, p3))
|
||||
if(SUCCESS != chain_step(&ns, p1, p3))
|
||||
goto error;
|
||||
|
||||
}
|
||||
|
@ -719,10 +739,13 @@ int connect_proxy_chain(int sock, ip_type target_ip,
|
|||
return -1;
|
||||
}
|
||||
|
||||
static pthread_mutex_t servbyname_lock;
|
||||
void core_initialize(void) {
|
||||
MUTEX_INIT(&servbyname_lock);
|
||||
}
|
||||
|
||||
void core_unload(void) {
|
||||
MUTEX_DESTROY(&servbyname_lock);
|
||||
}
|
||||
|
||||
static void gethostbyname_data_setstring(struct gethostbyname_data* data, char* name) {
|
||||
|
@ -730,7 +753,103 @@ static void gethostbyname_data_setstring(struct gethostbyname_data* data, char*
|
|||
data->hostent_space.h_name = data->addr_name;
|
||||
}
|
||||
|
||||
extern ip_type hostsreader_get_numeric_ip_for_name(const char* name);
|
||||
extern ip_type4 hostsreader_get_numeric_ip_for_name(const char* name);
|
||||
struct hostent* proxy_gethostbyname_old(const char *name)
|
||||
{
|
||||
static struct hostent hostent_space;
|
||||
static in_addr_t resolved_addr;
|
||||
static char* resolved_addr_p;
|
||||
static char addr_name[256];
|
||||
|
||||
int pipe_fd[2];
|
||||
char buff[256];
|
||||
in_addr_t addr;
|
||||
pid_t pid;
|
||||
int status, ret;
|
||||
size_t l;
|
||||
struct hostent* hp;
|
||||
|
||||
hostent_space.h_addr_list = &resolved_addr_p;
|
||||
*hostent_space.h_addr_list = (char*)&resolved_addr;
|
||||
resolved_addr = 0;
|
||||
|
||||
if(pc_isnumericipv4(name)) {
|
||||
strcpy(buff, name);
|
||||
goto got_buff;
|
||||
}
|
||||
|
||||
gethostname(buff,sizeof(buff));
|
||||
if(!strcmp(buff,name))
|
||||
goto got_buff;
|
||||
|
||||
memset(buff, 0, sizeof(buff));
|
||||
|
||||
// TODO: this works only once, so cache it ...
|
||||
// later
|
||||
while ((hp=gethostent()))
|
||||
if (!strcmp(hp->h_name,name))
|
||||
return hp;
|
||||
#ifdef HAVE_PIPE2
|
||||
ret = pipe2(pipe_fd, O_CLOEXEC);
|
||||
#else
|
||||
ret = pipe(pipe_fd);
|
||||
if(ret == 0) {
|
||||
fcntl(pipe_fd[0], F_SETFD, FD_CLOEXEC);
|
||||
fcntl(pipe_fd[1], F_SETFD, FD_CLOEXEC);
|
||||
}
|
||||
#endif
|
||||
|
||||
if(ret)
|
||||
goto err;
|
||||
pid = fork();
|
||||
switch(pid) {
|
||||
|
||||
case 0: // child
|
||||
proxychains_write_log("|DNS-request| %s \n", name);
|
||||
close(pipe_fd[0]);
|
||||
dup2(pipe_fd[1],1);
|
||||
close(pipe_fd[1]);
|
||||
|
||||
// putenv("LD_PRELOAD=");
|
||||
execlp("proxyresolv","proxyresolv",name,NULL);
|
||||
perror("can't exec proxyresolv");
|
||||
exit(2);
|
||||
|
||||
case -1: //error
|
||||
close(pipe_fd[0]);
|
||||
close(pipe_fd[1]);
|
||||
perror("can't fork");
|
||||
goto err;
|
||||
|
||||
default:
|
||||
close(pipe_fd[1]);
|
||||
waitpid(pid, &status, 0);
|
||||
buff[0] = 0;
|
||||
read(pipe_fd[0],&buff,sizeof(buff));
|
||||
close(pipe_fd[0]);
|
||||
got_buff:
|
||||
l = strlen(buff);
|
||||
if (!l) goto err_dns;
|
||||
if (buff[l-1] == '\n') buff[l-1] = 0;
|
||||
addr = inet_addr(buff);
|
||||
if (addr == (in_addr_t) (-1))
|
||||
goto err_dns;
|
||||
memcpy(*(hostent_space.h_addr_list),
|
||||
&addr ,sizeof(struct in_addr));
|
||||
hostent_space.h_name = addr_name;
|
||||
snprintf(addr_name, sizeof addr_name, "%s", buff);
|
||||
hostent_space.h_length = sizeof (in_addr_t);
|
||||
hostent_space.h_addrtype = AF_INET;
|
||||
}
|
||||
proxychains_write_log("|DNS-response| %s is %s\n",
|
||||
name, inet_ntoa(*(struct in_addr*)&addr));
|
||||
return &hostent_space;
|
||||
err_dns:
|
||||
proxychains_write_log("|DNS-response|: %s lookup error\n", name);
|
||||
err:
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct hostent *proxy_gethostbyname(const char *name, struct gethostbyname_data* data) {
|
||||
PFUNC();
|
||||
char buff[256];
|
||||
|
@ -746,24 +865,29 @@ struct hostent *proxy_gethostbyname(const char *name, struct gethostbyname_data*
|
|||
data->hostent_space.h_addrtype = AF_INET;
|
||||
data->hostent_space.h_length = sizeof(in_addr_t);
|
||||
|
||||
if(pc_isnumericipv4(name)) {
|
||||
data->resolved_addr = inet_addr(name);
|
||||
goto retname;
|
||||
}
|
||||
|
||||
gethostname(buff, sizeof(buff));
|
||||
|
||||
if(!strcmp(buff, name)) {
|
||||
data->resolved_addr = inet_addr(buff);
|
||||
if(data->resolved_addr == (in_addr_t) (-1))
|
||||
data->resolved_addr = (in_addr_t) (ip_type_localhost.as_int);
|
||||
data->resolved_addr = (in_addr_t) (IPT4_LOCALHOST.as_int);
|
||||
goto retname;
|
||||
}
|
||||
|
||||
// this iterates over the "known hosts" db, usually /etc/hosts
|
||||
ip_type hdb_res = hostsreader_get_numeric_ip_for_name(name);
|
||||
if(hdb_res.as_int != ip_type_invalid.as_int) {
|
||||
ip_type4 hdb_res = hostsreader_get_numeric_ip_for_name(name);
|
||||
if(hdb_res.as_int != IPT4_INVALID.as_int) {
|
||||
data->resolved_addr = hdb_res.as_int;
|
||||
goto retname;
|
||||
}
|
||||
|
||||
data->resolved_addr = at_get_ip_for_host((char*) name, strlen(name)).as_int;
|
||||
if(data->resolved_addr == (in_addr_t) ip_type_invalid.as_int) return NULL;
|
||||
data->resolved_addr = rdns_get_ip_for_host((char*) name, strlen(name)).as_int;
|
||||
if(data->resolved_addr == (in_addr_t) IPT4_INVALID.as_int) return NULL;
|
||||
|
||||
retname:
|
||||
|
||||
|
@ -776,7 +900,7 @@ struct hostent *proxy_gethostbyname(const char *name, struct gethostbyname_data*
|
|||
|
||||
struct addrinfo_data {
|
||||
struct addrinfo addrinfo_space;
|
||||
struct sockaddr sockaddr_space;
|
||||
struct sockaddr_storage sockaddr_space;
|
||||
char addr_name[256];
|
||||
};
|
||||
|
||||
|
@ -785,18 +909,17 @@ void proxy_freeaddrinfo(struct addrinfo *res) {
|
|||
free(res);
|
||||
}
|
||||
|
||||
#if defined(IS_MAC) || defined(IS_OPENBSD)
|
||||
#ifdef IS_OPENBSD /* OpenBSD has its own incompatible getservbyname_r */
|
||||
#define getservbyname_r mygetservbyname_r
|
||||
#endif
|
||||
/* getservbyname on mac is using thread local storage, so we dont need mutex
|
||||
TODO: check if the same applies to OpenBSD */
|
||||
static int getservbyname_r(const char* name, const char* proto, struct servent* result_buf,
|
||||
static int mygetservbyname_r(const char* name, const char* proto, struct servent* result_buf,
|
||||
char* buf, size_t buflen, struct servent** result) {
|
||||
PFUNC();
|
||||
#ifdef HAVE_GNU_GETSERVBYNAME_R
|
||||
PDEBUG("using host getservbyname_r\n");
|
||||
return getservbyname_r(name, proto, result_buf, buf, buflen, result);
|
||||
#endif
|
||||
struct servent *res;
|
||||
int ret;
|
||||
(void) buf; (void) buflen;
|
||||
MUTEX_LOCK(&servbyname_lock);
|
||||
res = getservbyname(name, proto);
|
||||
if(res) {
|
||||
*result_buf = *res;
|
||||
|
@ -806,9 +929,36 @@ static int getservbyname_r(const char* name, const char* proto, struct servent*
|
|||
*result = NULL;
|
||||
ret = ENOENT;
|
||||
}
|
||||
MUTEX_UNLOCK(&servbyname_lock);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int looks_like_numeric_ipv6(const char *node)
|
||||
{
|
||||
if(!strchr(node, ':')) return 0;
|
||||
const char* p= node;
|
||||
while(1) switch(*(p++)) {
|
||||
case 0: return 1;
|
||||
case ':': case '.':
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9':
|
||||
case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
|
||||
case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
|
||||
break;
|
||||
default: return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static int my_inet_aton(const char *node, struct addrinfo_data* space)
|
||||
{
|
||||
int ret;
|
||||
((struct sockaddr_in *) &space->sockaddr_space)->sin_family = AF_INET;
|
||||
ret = inet_aton(node, &((struct sockaddr_in *) &space->sockaddr_space)->sin_addr);
|
||||
if(ret || !looks_like_numeric_ipv6(node)) return ret;
|
||||
ret = inet_pton(AF_INET6, node, &((struct sockaddr_in6 *) &space->sockaddr_space)->sin6_addr);
|
||||
if(ret) ((struct sockaddr_in6 *) &space->sockaddr_space)->sin6_family = AF_INET6;
|
||||
return ret;
|
||||
}
|
||||
#endif
|
||||
|
||||
int proxy_getaddrinfo(const char *node, const char *service, const struct addrinfo *hints, struct addrinfo **res) {
|
||||
struct gethostbyname_data ghdata;
|
||||
|
@ -818,56 +968,69 @@ int proxy_getaddrinfo(const char *node, const char *service, const struct addrin
|
|||
struct servent se_buf;
|
||||
struct addrinfo *p;
|
||||
char buf[1024];
|
||||
int port;
|
||||
PFUNC();
|
||||
int port, af = AF_INET;
|
||||
|
||||
PDEBUG("proxy_getaddrinfo node:%s service: %s, flags: %d\n",
|
||||
node?node:"",service?service:"",hints?(int)hints->ai_flags:0);
|
||||
|
||||
// printf("proxy_getaddrinfo node %s service %s\n",node,service);
|
||||
space = calloc(1, sizeof(struct addrinfo_data));
|
||||
if(!space) goto err1;
|
||||
if(!space) return EAI_MEMORY;
|
||||
|
||||
if(node && !inet_aton(node, &((struct sockaddr_in *) &space->sockaddr_space)->sin_addr)) {
|
||||
if(node && !my_inet_aton(node, space)) {
|
||||
/* some folks (nmap) use getaddrinfo() with AI_NUMERICHOST to check whether a string
|
||||
containing a numeric ip was passed. we must return failure in that case. */
|
||||
if(hints && (hints->ai_flags & AI_NUMERICHOST)) return EAI_NONAME;
|
||||
hp = proxy_gethostbyname(node, &ghdata);
|
||||
if(hints && (hints->ai_flags & AI_NUMERICHOST)) {
|
||||
err_nn:
|
||||
free(space);
|
||||
return EAI_NONAME;
|
||||
}
|
||||
if(proxychains_resolver == DNSLF_FORKEXEC)
|
||||
hp = proxy_gethostbyname_old(node);
|
||||
else
|
||||
hp = proxy_gethostbyname(node, &ghdata);
|
||||
|
||||
if(hp)
|
||||
memcpy(&((struct sockaddr_in *) &space->sockaddr_space)->sin_addr,
|
||||
*(hp->h_addr_list), sizeof(in_addr_t));
|
||||
else
|
||||
goto err2;
|
||||
goto err_nn;
|
||||
} else if(node) {
|
||||
af = ((struct sockaddr_in *) &space->sockaddr_space)->sin_family;
|
||||
} else if(!node && !(hints->ai_flags & AI_PASSIVE)) {
|
||||
af = ((struct sockaddr_in *) &space->sockaddr_space)->sin_family = AF_INET;
|
||||
memcpy(&((struct sockaddr_in *) &space->sockaddr_space)->sin_addr,
|
||||
(char[]){127,0,0,1}, 4);
|
||||
}
|
||||
if(service) getservbyname_r(service, NULL, &se_buf, buf, sizeof(buf), &se);
|
||||
if(service) mygetservbyname_r(service, NULL, &se_buf, buf, sizeof(buf), &se);
|
||||
|
||||
port = se ? se->s_port : htons(atoi(service ? service : "0"));
|
||||
((struct sockaddr_in *) &space->sockaddr_space)->sin_port = port;
|
||||
if(af == AF_INET)
|
||||
((struct sockaddr_in *) &space->sockaddr_space)->sin_port = port;
|
||||
else
|
||||
((struct sockaddr_in6 *) &space->sockaddr_space)->sin6_port = port;
|
||||
|
||||
*res = p = &space->addrinfo_space;
|
||||
assert((size_t)p == (size_t) space);
|
||||
|
||||
p->ai_addr = &space->sockaddr_space;
|
||||
p->ai_addr = (void*) &space->sockaddr_space;
|
||||
if(node)
|
||||
snprintf(space->addr_name, sizeof(space->addr_name), "%s", node);
|
||||
p->ai_canonname = space->addr_name;
|
||||
p->ai_next = NULL;
|
||||
p->ai_family = space->sockaddr_space.sa_family = AF_INET;
|
||||
p->ai_addrlen = sizeof(space->sockaddr_space);
|
||||
p->ai_family = space->sockaddr_space.ss_family = af;
|
||||
p->ai_addrlen = af == AF_INET ? sizeof(struct sockaddr_in) : sizeof(struct sockaddr_in6);
|
||||
|
||||
if(hints) {
|
||||
p->ai_socktype = hints->ai_socktype;
|
||||
p->ai_flags = hints->ai_flags;
|
||||
p->ai_protocol = hints->ai_protocol;
|
||||
if(!p->ai_socktype && p->ai_protocol == IPPROTO_TCP)
|
||||
p->ai_socktype = SOCK_STREAM;
|
||||
} else {
|
||||
#ifndef AI_V4MAPPED
|
||||
#define AI_V4MAPPED 0
|
||||
#endif
|
||||
p->ai_flags = (AI_V4MAPPED | AI_ADDRCONFIG);
|
||||
}
|
||||
|
||||
goto out;
|
||||
err2:
|
||||
free(space);
|
||||
err1:
|
||||
return 1;
|
||||
out:
|
||||
return 0;
|
||||
}
|
||||
|
|
30
src/core.h
30
src/core.h
|
@ -23,8 +23,8 @@
|
|||
|
||||
#ifndef __CORE_HEADER
|
||||
#define __CORE_HEADER
|
||||
#define BUFF_SIZE 8*1024 // used to read responses from proxies.
|
||||
#define MAX_LOCALNET 64
|
||||
#define MAX_DNAT 64
|
||||
|
||||
#include "ip_type.h"
|
||||
|
||||
|
@ -41,7 +41,8 @@ typedef enum {
|
|||
typedef enum {
|
||||
HTTP_TYPE,
|
||||
SOCKS4_TYPE,
|
||||
SOCKS5_TYPE
|
||||
SOCKS5_TYPE,
|
||||
RAW_TYPE
|
||||
} proxy_type;
|
||||
|
||||
typedef enum {
|
||||
|
@ -64,10 +65,25 @@ typedef enum {
|
|||
} select_type;
|
||||
|
||||
typedef struct {
|
||||
struct in_addr in_addr, netmask;
|
||||
sa_family_t family;
|
||||
unsigned short port;
|
||||
union {
|
||||
struct {
|
||||
struct in_addr in_addr;
|
||||
struct in_addr in_mask;
|
||||
};
|
||||
struct {
|
||||
struct in6_addr in6_addr;
|
||||
unsigned char in6_prefix;
|
||||
};
|
||||
};
|
||||
} localaddr_arg;
|
||||
|
||||
typedef struct {
|
||||
struct in_addr orig_dst, new_dst;
|
||||
unsigned short orig_port, new_port;
|
||||
} dnat_arg;
|
||||
|
||||
typedef struct {
|
||||
ip_type ip;
|
||||
unsigned short port;
|
||||
|
@ -84,16 +100,17 @@ int connect_proxy_chain (int sock, ip_type target_ip, unsigned short target_port
|
|||
void proxychains_write_log(char *str, ...);
|
||||
|
||||
typedef int (*close_t)(int);
|
||||
typedef int (*close_range_t)(unsigned, unsigned, int);
|
||||
typedef int (*connect_t)(int, const struct sockaddr *, socklen_t);
|
||||
typedef struct hostent* (*gethostbyname_t)(const char *);
|
||||
typedef int (*freeaddrinfo_t)(struct addrinfo *);
|
||||
typedef void (*freeaddrinfo_t)(struct addrinfo *);
|
||||
typedef struct hostent *(*gethostbyaddr_t) (const void *, socklen_t, int);
|
||||
|
||||
typedef int (*getaddrinfo_t)(const char *, const char *, const struct addrinfo *,
|
||||
struct addrinfo **);
|
||||
|
||||
typedef int (*getnameinfo_t) (const struct sockaddr *, socklen_t, char *,
|
||||
socklen_t, char *, socklen_t, int);
|
||||
GN_NODELEN_T, char *, GN_SERVLEN_T, GN_FLAGS_T);
|
||||
|
||||
typedef ssize_t (*sendto_t) (int sockfd, const void *buf, size_t len, int flags,
|
||||
const struct sockaddr *dest_addr, socklen_t addrlen);
|
||||
|
@ -111,10 +128,11 @@ struct gethostbyname_data {
|
|||
struct hostent hostent_space;
|
||||
in_addr_t resolved_addr;
|
||||
char *resolved_addr_p[2];
|
||||
char addr_name[1024 * 8];
|
||||
char addr_name[256];
|
||||
};
|
||||
|
||||
struct hostent* proxy_gethostbyname(const char *name, struct gethostbyname_data *data);
|
||||
struct hostent* proxy_gethostbyname_old(const char *name);
|
||||
|
||||
int proxy_getaddrinfo(const char *node, const char *service,
|
||||
const struct addrinfo *hints, struct addrinfo **res);
|
||||
|
|
|
@ -0,0 +1,231 @@
|
|||
/*
|
||||
proxychains-ng DNS daemon
|
||||
|
||||
Copyright (C) 2020 rofl0r.
|
||||
|
||||
*/
|
||||
|
||||
#define _GNU_SOURCE
|
||||
#include <unistd.h>
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
#include <pthread.h>
|
||||
#include <signal.h>
|
||||
#include <sys/select.h>
|
||||
#include <arpa/inet.h>
|
||||
#include <errno.h>
|
||||
#include <limits.h>
|
||||
#include "udpserver.h"
|
||||
#include "sblist.h"
|
||||
#include "hsearch.h"
|
||||
#include "../remotedns.h"
|
||||
#include "../ip_type.h"
|
||||
|
||||
#ifndef MAX
|
||||
#define MAX(x, y) ((x) > (y) ? (x) : (y))
|
||||
#endif
|
||||
|
||||
static struct htab *ip_lookup_table;
|
||||
static sblist *hostnames;
|
||||
static unsigned remote_subnet;
|
||||
static const struct server* server;
|
||||
|
||||
#ifndef CONFIG_LOG
|
||||
#define CONFIG_LOG 1
|
||||
#endif
|
||||
#if CONFIG_LOG
|
||||
/* we log to stderr because it's not using line buffering, i.e. malloc which would need
|
||||
locking when called from different threads. for the same reason we use dprintf,
|
||||
which writes directly to an fd. */
|
||||
#define dolog(...) dprintf(2, __VA_ARGS__)
|
||||
#else
|
||||
static void dolog(const char* fmt, ...) { }
|
||||
#endif
|
||||
|
||||
static char* my_inet_ntoa(unsigned char *ip_buf_4_bytes, char *outbuf_16_bytes) {
|
||||
unsigned char *p;
|
||||
char *o = outbuf_16_bytes;
|
||||
unsigned char n;
|
||||
for(p = ip_buf_4_bytes; p < ip_buf_4_bytes + 4; p++) {
|
||||
n = *p;
|
||||
if(*p >= 100) {
|
||||
if(*p >= 200)
|
||||
*(o++) = '2';
|
||||
else
|
||||
*(o++) = '1';
|
||||
n %= 100;
|
||||
}
|
||||
if(*p >= 10) {
|
||||
*(o++) = (n / 10) + '0';
|
||||
n %= 10;
|
||||
}
|
||||
*(o++) = n + '0';
|
||||
*(o++) = '.';
|
||||
}
|
||||
o[-1] = 0;
|
||||
return outbuf_16_bytes;
|
||||
}
|
||||
|
||||
|
||||
/* buf needs to be long enough for an ipv6 addr, i.e. INET6_ADDRSTRLEN + 1 */
|
||||
static char* ipstr(union sockaddr_union *su, char* buf) {
|
||||
int af = SOCKADDR_UNION_AF(su);
|
||||
void *ipdata = SOCKADDR_UNION_ADDRESS(su);
|
||||
inet_ntop(af, ipdata, buf, INET6_ADDRSTRLEN+1);
|
||||
char portbuf[7];
|
||||
snprintf(portbuf, sizeof portbuf, ":%u", (unsigned) ntohs(SOCKADDR_UNION_PORT(su)));
|
||||
strcat(buf, portbuf);
|
||||
return buf;
|
||||
}
|
||||
|
||||
static int usage(char *a0) {
|
||||
dprintf(2,
|
||||
"Proxychains-NG remote dns daemon\n"
|
||||
"--------------------------------\n"
|
||||
"usage: %s -i listenip -p port -r remotesubnet\n"
|
||||
"all arguments are optional.\n"
|
||||
"by default listenip is 127.0.0.1, port 1053 and remotesubnet 224.\n\n", a0
|
||||
);
|
||||
return 1;
|
||||
}
|
||||
|
||||
unsigned index_from_ip(ip_type4 internalip) {
|
||||
ip_type4 tmp = internalip;
|
||||
uint32_t ret;
|
||||
ret = tmp.octet[3] + (tmp.octet[2] << 8) + (tmp.octet[1] << 16);
|
||||
ret -= 1;
|
||||
return ret;
|
||||
}
|
||||
|
||||
char *host_from_ip(ip_type4 internalip) {
|
||||
char *res = NULL;
|
||||
unsigned index = index_from_ip(internalip);
|
||||
if(index < sblist_getsize(hostnames)) {
|
||||
char **tmp = sblist_get(hostnames, index);
|
||||
if(tmp && *tmp) res = *tmp;
|
||||
}
|
||||
return res;
|
||||
}
|
||||
|
||||
ip_type4 get_ip_from_index(unsigned index) {
|
||||
ip_type4 ret;
|
||||
index++; // so we can start at .0.0.1
|
||||
if(index > 0xFFFFFF)
|
||||
return IPT4_INVALID;
|
||||
ret.octet[0] = remote_subnet & 0xFF;
|
||||
ret.octet[1] = (index & 0xFF0000) >> 16;
|
||||
ret.octet[2] = (index & 0xFF00) >> 8;
|
||||
ret.octet[3] = index & 0xFF;
|
||||
return ret;
|
||||
}
|
||||
|
||||
ip_type4 get_ip(char* hn) {
|
||||
htab_value *v = htab_find(ip_lookup_table, hn);
|
||||
if(v) return get_ip_from_index(v->n);
|
||||
char *n = strdup(hn);
|
||||
if(!n) return IPT4_INVALID;
|
||||
if(!sblist_add(hostnames, &n)) {
|
||||
o_out:;
|
||||
free(n);
|
||||
return IPT4_INVALID;
|
||||
}
|
||||
if(!htab_insert(ip_lookup_table, n, HTV_N(sblist_getsize(hostnames)-1))) {
|
||||
sblist_delete(hostnames, sblist_getsize(hostnames)-1);
|
||||
goto o_out;
|
||||
}
|
||||
return get_ip_from_index(sblist_getsize(hostnames)-1);
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
int ch;
|
||||
const char *listenip = "127.0.0.1";
|
||||
unsigned port = 1053;
|
||||
remote_subnet = 224;
|
||||
while((ch = getopt(argc, argv, ":r:i:p:")) != -1) {
|
||||
switch(ch) {
|
||||
case 'r':
|
||||
remote_subnet = atoi(optarg);
|
||||
break;
|
||||
case 'i':
|
||||
listenip = optarg;
|
||||
break;
|
||||
case 'p':
|
||||
port = atoi(optarg);
|
||||
break;
|
||||
case ':':
|
||||
dprintf(2, "error: option -%c requires an operand\n", optopt);
|
||||
/* fall through */
|
||||
case '?':
|
||||
return usage(argv[0]);
|
||||
}
|
||||
}
|
||||
signal(SIGPIPE, SIG_IGN);
|
||||
struct server s;
|
||||
if(server_setup(&s, listenip, port)) {
|
||||
perror("server_setup");
|
||||
return 1;
|
||||
}
|
||||
server = &s;
|
||||
|
||||
ip_lookup_table = htab_create(64);
|
||||
hostnames = sblist_new(sizeof(char*), 64);
|
||||
|
||||
while(1) {
|
||||
struct client c;
|
||||
char ipstr_buf[INET6_ADDRSTRLEN+6+1];
|
||||
char ip4str_buf[16];
|
||||
struct at_msg msg, out;
|
||||
size_t msgl = sizeof(msg);
|
||||
int failed = 0;
|
||||
|
||||
#define FAIL() do { failed=1; goto sendresp; } while(0)
|
||||
|
||||
if(server_waitclient(&s, &c, &msg, &msgl)) continue;
|
||||
msg.h.datalen = ntohs(msg.h.datalen);
|
||||
if(msgl != sizeof(msg.h)+msg.h.datalen) {
|
||||
dolog("%s: invalid datalen\n", ipstr(&c.addr, ipstr_buf));
|
||||
FAIL();
|
||||
}
|
||||
|
||||
out.h.msgtype = msg.h.msgtype;
|
||||
if(msg.h.msgtype == ATM_GETIP) {
|
||||
if(!memchr(msg.m.host, 0, msg.h.datalen)) {
|
||||
dolog("%s: nul terminator missing\n", ipstr(&c.addr, ipstr_buf));
|
||||
FAIL();
|
||||
}
|
||||
out.h.datalen = sizeof(ip_type4);
|
||||
out.m.ip = get_ip(msg.m.host);
|
||||
failed = !memcmp(&out.m.ip, &IPT4_INVALID, 4);
|
||||
dolog("%s requested ip for %s (%s)\n", ipstr(&c.addr, ipstr_buf),
|
||||
msg.m.host, failed?"FAIL":my_inet_ntoa((void*)&out.m.ip, ip4str_buf));
|
||||
if(failed) FAIL();
|
||||
} else if (msg.h.msgtype == ATM_GETNAME) {
|
||||
if(msg.h.datalen != 4) {
|
||||
dolog("%s: invalid len for getname request\n", ipstr(&c.addr, ipstr_buf));
|
||||
FAIL();
|
||||
}
|
||||
char *hn = host_from_ip(msg.m.ip);
|
||||
if(hn) {
|
||||
size_t l = strlen(hn);
|
||||
memcpy(out.m.host, hn, l+1);
|
||||
out.h.datalen = l+1;
|
||||
}
|
||||
dolog("%s requested name for %s (%s)\n", ipstr(&c.addr, ipstr_buf),
|
||||
my_inet_ntoa((void*) &msg.m.ip, ip4str_buf), hn?hn:"FAIL");
|
||||
if(!hn) FAIL();
|
||||
} else {
|
||||
dolog("%s: unknown request %u\n", ipstr(&c.addr, ipstr_buf),
|
||||
(unsigned) msg.h.msgtype);
|
||||
}
|
||||
sendresp:;
|
||||
if(failed) {
|
||||
out.h.msgtype = ATM_FAIL;
|
||||
out.h.datalen = 0;
|
||||
}
|
||||
unsigned short dlen = out.h.datalen;
|
||||
out.h.datalen = htons(dlen);
|
||||
sendto(server->fd, &out, sizeof(out.h)+dlen, 0, (void*) &c.addr, SOCKADDR_UNION_LENGTH(&c.addr));
|
||||
}
|
||||
}
|
|
@ -0,0 +1,188 @@
|
|||
/*
|
||||
musl license, hsearch.c originally written by Szabolcs Nagy
|
||||
|
||||
Copyright © 2005-2020 Rich Felker, et al.
|
||||
|
||||
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.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#include "hsearch.h"
|
||||
|
||||
/*
|
||||
open addressing hash table with 2^n table size
|
||||
quadratic probing is used in case of hash collision
|
||||
tab indices and hash are size_t
|
||||
after resize fails with ENOMEM the state of tab is still usable
|
||||
*/
|
||||
|
||||
typedef struct htab_entry {
|
||||
char *key;
|
||||
htab_value data;
|
||||
} htab_entry;
|
||||
|
||||
struct elem {
|
||||
htab_entry item;
|
||||
size_t hash;
|
||||
};
|
||||
|
||||
struct htab {
|
||||
struct elem *elems;
|
||||
size_t mask;
|
||||
size_t used;
|
||||
};
|
||||
|
||||
#define MINSIZE 8
|
||||
#define MAXSIZE ((size_t)-1/2 + 1)
|
||||
|
||||
static size_t keyhash(char *k)
|
||||
{
|
||||
unsigned char *p = (void *)k;
|
||||
size_t h = 0;
|
||||
|
||||
while (*p)
|
||||
h = 31*h + *p++;
|
||||
return h;
|
||||
}
|
||||
|
||||
static int resize(struct htab *htab, size_t nel)
|
||||
{
|
||||
size_t newsize;
|
||||
size_t i, j;
|
||||
struct elem *e, *newe;
|
||||
struct elem *oldtab = htab->elems;
|
||||
struct elem *oldend = htab->elems + htab->mask + 1;
|
||||
|
||||
if (nel > MAXSIZE)
|
||||
nel = MAXSIZE;
|
||||
for (newsize = MINSIZE; newsize < nel; newsize *= 2);
|
||||
htab->elems = calloc(newsize, sizeof *htab->elems);
|
||||
if (!htab->elems) {
|
||||
htab->elems = oldtab;
|
||||
return 0;
|
||||
}
|
||||
htab->mask = newsize - 1;
|
||||
if (!oldtab)
|
||||
return 1;
|
||||
for (e = oldtab; e < oldend; e++)
|
||||
if (e->item.key) {
|
||||
for (i=e->hash,j=1; ; i+=j++) {
|
||||
newe = htab->elems + (i & htab->mask);
|
||||
if (!newe->item.key)
|
||||
break;
|
||||
}
|
||||
*newe = *e;
|
||||
}
|
||||
free(oldtab);
|
||||
return 1;
|
||||
}
|
||||
|
||||
static struct elem *lookup(struct htab *htab, char *key, size_t hash)
|
||||
{
|
||||
size_t i, j;
|
||||
struct elem *e;
|
||||
|
||||
for (i=hash,j=1; ; i+=j++) {
|
||||
e = htab->elems + (i & htab->mask);
|
||||
if (!e->item.key ||
|
||||
(e->hash==hash && strcmp(e->item.key, key)==0))
|
||||
break;
|
||||
}
|
||||
return e;
|
||||
}
|
||||
|
||||
struct htab *htab_create(size_t nel)
|
||||
{
|
||||
struct htab *r = calloc(1, sizeof *r);
|
||||
if(r && !resize(r, nel)) {
|
||||
free(r);
|
||||
r = 0;
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
void htab_destroy(struct htab *htab)
|
||||
{
|
||||
free(htab->elems);
|
||||
free(htab);
|
||||
}
|
||||
|
||||
static htab_entry *htab_find_item(struct htab *htab, char* key)
|
||||
{
|
||||
size_t hash = keyhash(key);
|
||||
struct elem *e = lookup(htab, key, hash);
|
||||
|
||||
if (e->item.key) {
|
||||
return &e->item;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
htab_value* htab_find(struct htab *htab, char* key)
|
||||
{
|
||||
htab_entry *i = htab_find_item(htab, key);
|
||||
if(i) return &i->data;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int htab_delete(struct htab *htab, char* key)
|
||||
{
|
||||
htab_entry *i = htab_find_item(htab, key);
|
||||
if(!i) return 0;
|
||||
i->key = 0;
|
||||
return 1;
|
||||
}
|
||||
|
||||
int htab_insert(struct htab *htab, char* key, htab_value value)
|
||||
{
|
||||
size_t hash = keyhash(key);
|
||||
struct elem *e = lookup(htab, key, hash);
|
||||
if(e->item.key) {
|
||||
/* it's not allowed to overwrite existing data */
|
||||
return 0;
|
||||
}
|
||||
|
||||
e->item.key = key;
|
||||
e->item.data = value;
|
||||
e->hash = hash;
|
||||
if (++htab->used > htab->mask - htab->mask/4) {
|
||||
if (!resize(htab, 2*htab->used)) {
|
||||
htab->used--;
|
||||
e->item.key = 0;
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
size_t htab_next(struct htab *htab, size_t iterator, char** key, htab_value **v)
|
||||
{
|
||||
size_t i;
|
||||
for(i=iterator;i<htab->mask+1;++i) {
|
||||
struct elem *e = htab->elems + i;
|
||||
if(e->item.key) {
|
||||
*key = e->item.key;
|
||||
*v = &e->item.data;
|
||||
return i+1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
|
@ -0,0 +1,21 @@
|
|||
#ifndef HSEARCH_H
|
||||
#define HSEARCH_H
|
||||
|
||||
#include <stdlib.h>
|
||||
|
||||
typedef union htab_value {
|
||||
void *p;
|
||||
size_t n;
|
||||
} htab_value;
|
||||
|
||||
#define HTV_N(N) (htab_value) {.n = N}
|
||||
#define HTV_P(P) (htab_value) {.p = P}
|
||||
|
||||
struct htab * htab_create(size_t);
|
||||
void htab_destroy(struct htab *);
|
||||
htab_value* htab_find(struct htab *, char* key);
|
||||
int htab_insert(struct htab *, char*, htab_value);
|
||||
int htab_delete(struct htab *htab, char* key);
|
||||
size_t htab_next(struct htab *, size_t iterator, char** key, htab_value **v);
|
||||
|
||||
#endif
|
|
@ -0,0 +1,73 @@
|
|||
#undef _POSIX_C_SOURCE
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#include "sblist.h"
|
||||
#include <limits.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
#define MY_PAGE_SIZE 4096
|
||||
|
||||
sblist* sblist_new(size_t itemsize, size_t blockitems) {
|
||||
sblist* ret = (sblist*) malloc(sizeof(sblist));
|
||||
sblist_init(ret, itemsize, blockitems);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static void sblist_clear(sblist* l) {
|
||||
l->items = NULL;
|
||||
l->capa = 0;
|
||||
l->count = 0;
|
||||
}
|
||||
|
||||
void sblist_init(sblist* l, size_t itemsize, size_t blockitems) {
|
||||
if(l) {
|
||||
l->blockitems = blockitems ? blockitems : MY_PAGE_SIZE / itemsize;
|
||||
l->itemsize = itemsize;
|
||||
sblist_clear(l);
|
||||
}
|
||||
}
|
||||
|
||||
void sblist_free_items(sblist* l) {
|
||||
if(l) {
|
||||
if(l->items) free(l->items);
|
||||
sblist_clear(l);
|
||||
}
|
||||
}
|
||||
|
||||
void sblist_free(sblist* l) {
|
||||
if(l) {
|
||||
sblist_free_items(l);
|
||||
free(l);
|
||||
}
|
||||
}
|
||||
|
||||
char* sblist_item_from_index(sblist* l, size_t idx) {
|
||||
return l->items + (idx * l->itemsize);
|
||||
}
|
||||
|
||||
void* sblist_get(sblist* l, size_t item) {
|
||||
if(item < l->count) return (void*) sblist_item_from_index(l, item);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int sblist_set(sblist* l, void* item, size_t pos) {
|
||||
if(pos >= l->count) return 0;
|
||||
memcpy(sblist_item_from_index(l, pos), item, l->itemsize);
|
||||
return 1;
|
||||
}
|
||||
|
||||
int sblist_grow_if_needed(sblist* l) {
|
||||
char* temp;
|
||||
if(l->count == l->capa) {
|
||||
temp = realloc(l->items, (l->capa + l->blockitems) * l->itemsize);
|
||||
if(!temp) return 0;
|
||||
l->capa += l->blockitems;
|
||||
l->items = temp;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
int sblist_add(sblist* l, void* item) {
|
||||
if(!sblist_grow_if_needed(l)) return 0;
|
||||
l->count++;
|
||||
return sblist_set(l, item, l->count - 1);
|
||||
}
|
|
@ -0,0 +1,92 @@
|
|||
#ifndef SBLIST_H
|
||||
#define SBLIST_H
|
||||
|
||||
/* this file is part of libulz, as of commit 8ab361a27743aaf025323ee43b8b8876dc054fdd
|
||||
modified for direct inclusion in microsocks. */
|
||||
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stddef.h>
|
||||
/*
|
||||
* simple buffer list.
|
||||
*
|
||||
* this thing here is basically a generic dynamic array
|
||||
* will realloc after every blockitems inserts
|
||||
* can store items of any size.
|
||||
*
|
||||
* so think of it as a by-value list, as opposed to a typical by-ref list.
|
||||
* you typically use it by having some struct on the stack, and pass a pointer
|
||||
* to sblist_add, which will copy the contents into its internal memory.
|
||||
*
|
||||
*/
|
||||
|
||||
typedef struct {
|
||||
size_t itemsize;
|
||||
size_t blockitems;
|
||||
size_t count;
|
||||
size_t capa;
|
||||
char* items;
|
||||
} sblist;
|
||||
|
||||
#define sblist_getsize(X) ((X)->count)
|
||||
#define sblist_get_count(X) ((X)->count)
|
||||
#define sblist_empty(X) ((X)->count == 0)
|
||||
|
||||
// for dynamic style
|
||||
sblist* sblist_new(size_t itemsize, size_t blockitems);
|
||||
void sblist_free(sblist* l);
|
||||
|
||||
//for static style
|
||||
void sblist_init(sblist* l, size_t itemsize, size_t blockitems);
|
||||
void sblist_free_items(sblist* l);
|
||||
|
||||
// accessors
|
||||
void* sblist_get(sblist* l, size_t item);
|
||||
// returns 1 on success, 0 on OOM
|
||||
int sblist_add(sblist* l, void* item);
|
||||
int sblist_set(sblist* l, void* item, size_t pos);
|
||||
void sblist_delete(sblist* l, size_t item);
|
||||
char* sblist_item_from_index(sblist* l, size_t idx);
|
||||
int sblist_grow_if_needed(sblist* l);
|
||||
int sblist_insert(sblist* l, void* item, size_t pos);
|
||||
/* same as sblist_add, but returns list index of new item, or -1 */
|
||||
size_t sblist_addi(sblist* l, void* item);
|
||||
void sblist_sort(sblist *l, int (*compar)(const void *, const void *));
|
||||
/* insert element into presorted list, returns listindex of new entry or -1*/
|
||||
size_t sblist_insert_sorted(sblist* l, void* o, int (*compar)(const void *, const void *));
|
||||
|
||||
#ifndef __COUNTER__
|
||||
#define __COUNTER__ __LINE__
|
||||
#endif
|
||||
|
||||
#define __sblist_concat_impl( x, y ) x##y
|
||||
#define __sblist_macro_concat( x, y ) __sblist_concat_impl( x, y )
|
||||
#define __sblist_iterator_name __sblist_macro_concat(sblist_iterator, __COUNTER__)
|
||||
|
||||
// use with custom iterator variable
|
||||
#define sblist_iter_counter(LIST, ITER, PTR) \
|
||||
for(size_t ITER = 0; (PTR = sblist_get(LIST, ITER)), ITER < sblist_getsize(LIST); ITER++)
|
||||
|
||||
// use with custom iterator variable, which is predeclared
|
||||
#define sblist_iter_counter2(LIST, ITER, PTR) \
|
||||
for(ITER = 0; (PTR = sblist_get(LIST, ITER)), ITER < sblist_getsize(LIST); ITER++)
|
||||
|
||||
// use with custom iterator variable, which is predeclared and signed
|
||||
// useful for a loop which can delete items from the list, and then decrease the iterator var.
|
||||
#define sblist_iter_counter2s(LIST, ITER, PTR) \
|
||||
for(ITER = 0; (PTR = sblist_get(LIST, ITER)), ITER < (ssize_t) sblist_getsize(LIST); ITER++)
|
||||
|
||||
|
||||
// uses "magic" iterator variable
|
||||
#define sblist_iter(LIST, PTR) sblist_iter_counter(LIST, __sblist_iterator_name, PTR)
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#pragma RcB2 DEP "sblist.c" "sblist_delete.c"
|
||||
|
||||
#endif
|
|
@ -0,0 +1,9 @@
|
|||
#include "sblist.h"
|
||||
#include <string.h>
|
||||
|
||||
void sblist_delete(sblist* l, size_t item) {
|
||||
if (l->count && item < l->count) {
|
||||
memmove(sblist_item_from_index(l, item), sblist_item_from_index(l, item + 1), (sblist_getsize(l) - (item + 1)) * l->itemsize);
|
||||
l->count--;
|
||||
}
|
||||
}
|
|
@ -0,0 +1,41 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <sys/types.h>
|
||||
#include <sys/socket.h>
|
||||
#include <netinet/in.h>
|
||||
#include <arpa/inet.h>
|
||||
#include "../remotedns.h"
|
||||
#include "../ip_type.h"
|
||||
|
||||
int main() {
|
||||
int fd;
|
||||
int port = 1053;
|
||||
char srvn[] = "127.0.0.1";
|
||||
struct sockaddr_in srva = {.sin_family = AF_INET, .sin_port = htons(port)};
|
||||
inet_pton(AF_INET, srvn, &srva.sin_addr);
|
||||
fd = socket(AF_INET, SOCK_DGRAM, 0);
|
||||
char namebuf[260];
|
||||
while(fgets(namebuf, sizeof namebuf, stdin)) {
|
||||
size_t l = strlen(namebuf);
|
||||
if(namebuf[l-1] == '\n') {
|
||||
l--;
|
||||
namebuf[l] = 0;
|
||||
}
|
||||
struct at_msg msg = {0};
|
||||
unsigned msglen;
|
||||
if(isdigit(namebuf[0])) {
|
||||
msglen = 4;
|
||||
msg.h.msgtype = ATM_GETNAME;
|
||||
inet_aton(namebuf, (void*) &msg.m.ip);
|
||||
} else {
|
||||
msglen = l+1;
|
||||
msg.h.msgtype = ATM_GETIP;
|
||||
memcpy(msg.m.host, namebuf, msglen);
|
||||
}
|
||||
msg.h.datalen = htons(msglen);
|
||||
sendto(fd, &msg, sizeof(msg.h)+msglen, 0, (void*)&srva, sizeof(srva));
|
||||
char rcvbuf[512];
|
||||
recvfrom(fd, rcvbuf, sizeof rcvbuf, 0, (void*)0, (void*)0);
|
||||
}
|
||||
}
|
|
@ -0,0 +1,65 @@
|
|||
#include "udpserver.h"
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
int resolve(const char *host, unsigned short port, struct addrinfo** addr) {
|
||||
struct addrinfo hints = {
|
||||
.ai_family = AF_UNSPEC,
|
||||
.ai_socktype = SOCK_STREAM,
|
||||
.ai_flags = AI_PASSIVE,
|
||||
};
|
||||
char port_buf[8];
|
||||
snprintf(port_buf, sizeof port_buf, "%u", port);
|
||||
return getaddrinfo(host, port_buf, &hints, addr);
|
||||
}
|
||||
|
||||
int resolve_sa(const char *host, unsigned short port, union sockaddr_union *res) {
|
||||
struct addrinfo *ainfo = 0;
|
||||
int ret;
|
||||
SOCKADDR_UNION_AF(res) = AF_UNSPEC;
|
||||
if((ret = resolve(host, port, &ainfo))) return ret;
|
||||
memcpy(res, ainfo->ai_addr, ainfo->ai_addrlen);
|
||||
freeaddrinfo(ainfo);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int bindtoip(int fd, union sockaddr_union *bindaddr) {
|
||||
socklen_t sz = SOCKADDR_UNION_LENGTH(bindaddr);
|
||||
if(sz)
|
||||
return bind(fd, (struct sockaddr*) bindaddr, sz);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int server_waitclient(struct server *server, struct client* client, void* buf, size_t *buflen) {
|
||||
socklen_t clen = sizeof client->addr;
|
||||
ssize_t ret = recvfrom(server->fd, buf, *buflen, 0, (void*)&client->addr, &clen);
|
||||
if(ret >= 0) {
|
||||
*buflen = ret;
|
||||
return 0;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
int server_setup(struct server *server, const char* listenip, unsigned short port) {
|
||||
struct addrinfo *ainfo = 0;
|
||||
if(resolve(listenip, port, &ainfo)) return -1;
|
||||
struct addrinfo* p;
|
||||
int listenfd = -1;
|
||||
for(p = ainfo; p; p = p->ai_next) {
|
||||
if((listenfd = socket(p->ai_family, SOCK_DGRAM, 0)) < 0)
|
||||
continue;
|
||||
int yes = 1;
|
||||
setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int));
|
||||
if(bind(listenfd, p->ai_addr, p->ai_addrlen) < 0) {
|
||||
close(listenfd);
|
||||
listenfd = -1;
|
||||
continue;
|
||||
}
|
||||
break;
|
||||
}
|
||||
freeaddrinfo(ainfo);
|
||||
if(listenfd < 0) return -2;
|
||||
server->fd = listenfd;
|
||||
return 0;
|
||||
}
|
|
@ -0,0 +1,48 @@
|
|||
#ifndef SERVER_H
|
||||
#define SERVER_H
|
||||
|
||||
#undef _POSIX_C_SOURCE
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
|
||||
#include <sys/socket.h>
|
||||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
|
||||
#pragma RcB2 DEP "udpserver.c"
|
||||
|
||||
union sockaddr_union {
|
||||
struct sockaddr_in v4;
|
||||
struct sockaddr_in6 v6;
|
||||
};
|
||||
|
||||
#define SOCKADDR_UNION_AF(PTR) (PTR)->v4.sin_family
|
||||
|
||||
#define SOCKADDR_UNION_LENGTH(PTR) ( \
|
||||
( SOCKADDR_UNION_AF(PTR) == AF_INET ) ? sizeof((PTR)->v4) : ( \
|
||||
( SOCKADDR_UNION_AF(PTR) == AF_INET6 ) ? sizeof((PTR)->v6) : 0 ) )
|
||||
|
||||
#define SOCKADDR_UNION_ADDRESS(PTR) ( \
|
||||
( SOCKADDR_UNION_AF(PTR) == AF_INET ) ? (void*) &(PTR)->v4.sin_addr : ( \
|
||||
( SOCKADDR_UNION_AF(PTR) == AF_INET6 ) ? (void*) &(PTR)->v6.sin6_addr : (void*) 0 ) )
|
||||
|
||||
#define SOCKADDR_UNION_PORT(PTR) ( \
|
||||
( SOCKADDR_UNION_AF(PTR) == AF_INET ) ? (PTR)->v4.sin_port : ( \
|
||||
( SOCKADDR_UNION_AF(PTR) == AF_INET6 ) ? (PTR)->v6.sin6_port : 0 ) )
|
||||
|
||||
struct client {
|
||||
union sockaddr_union addr;
|
||||
};
|
||||
|
||||
struct server {
|
||||
int fd;
|
||||
};
|
||||
|
||||
int resolve(const char *host, unsigned short port, struct addrinfo** addr);
|
||||
int resolve_sa(const char *host, unsigned short port, union sockaddr_union *res);
|
||||
int bindtoip(int fd, union sockaddr_union *bindaddr);
|
||||
|
||||
int server_waitclient(struct server *server, struct client* client, void* buf, size_t *buflen);
|
||||
int server_setup(struct server *server, const char* listenip, unsigned short port);
|
||||
|
||||
#endif
|
||||
|
16
src/debug.c
16
src/debug.c
|
@ -3,11 +3,15 @@
|
|||
# include "core.h"
|
||||
# include "common.h"
|
||||
# include "debug.h"
|
||||
#include <arpa/inet.h>
|
||||
|
||||
void DUMP_PROXY_CHAIN(proxy_data *pchain, unsigned int count) {
|
||||
char ip_buf[16];
|
||||
void dump_proxy_chain(proxy_data *pchain, unsigned int count) {
|
||||
char ip_buf[INET6_ADDRSTRLEN];
|
||||
for (; count; pchain++, count--) {
|
||||
pc_stringfromipv4(&pchain->ip.octet[0], ip_buf);
|
||||
if(!inet_ntop(pchain->ip.is_v6?AF_INET6:AF_INET,pchain->ip.addr.v6,ip_buf,sizeof ip_buf)) {
|
||||
proxychains_write_log(LOG_PREFIX "error: ip address conversion failed\n");
|
||||
continue;
|
||||
}
|
||||
PDEBUG("[%s] %s %s:%d", proxy_state_strmap[pchain->ps],
|
||||
proxy_type_strmap[pchain->pt],
|
||||
ip_buf, htons(pchain->port));
|
||||
|
@ -18,4 +22,10 @@ void DUMP_PROXY_CHAIN(proxy_data *pchain, unsigned int count) {
|
|||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
// Do not allow this translation unit to end up empty
|
||||
// for non-DEBUG builds, to satisfy ISO C standards.
|
||||
typedef int __appease_iso_compilers__;
|
||||
|
||||
#endif
|
||||
|
|
18
src/debug.h
18
src/debug.h
|
@ -1,20 +1,24 @@
|
|||
#ifndef DEBUG_H
|
||||
#define DEBUG_H
|
||||
|
||||
#ifdef DEBUG
|
||||
# include <stdio.h>
|
||||
|
||||
#ifdef DEBUG
|
||||
# define PSTDERR(fmt, args...) do { dprintf(2,fmt, ## args); } while(0)
|
||||
# define PDEBUG(fmt, args...) PSTDERR("DEBUG:"fmt, ## args)
|
||||
|
||||
# include "core.h"
|
||||
void DUMP_PROXY_CHAIN(proxy_data *pchain, unsigned int count);
|
||||
|
||||
# define PDEBUG(fmt, args...) PSTDERR("DEBUG:pid[%d]:" fmt, getpid(), ## args)
|
||||
# define DEBUGDECL(args...) args
|
||||
# define DUMP_PROXY_CHAIN(A, B) dump_proxy_chain(A, B)
|
||||
#else
|
||||
# define PDEBUG(fmt, args...) do {} while (0)
|
||||
# define DEBUGDECL(args...)
|
||||
# define DUMP_PROXY_CHAIN(args...) do {} while (0)
|
||||
#endif
|
||||
|
||||
# define PFUNC() do { PDEBUG("pid[%d]:%s\n", getpid(), __FUNCTION__); } while(0)
|
||||
# define PFUNC() do { PDEBUG("%s()\n", __FUNCTION__); } while(0)
|
||||
|
||||
#include "core.h"
|
||||
void dump_proxy_chain(proxy_data *pchain, unsigned int count);
|
||||
|
||||
|
||||
#endif
|
||||
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
#include <stdio.h>
|
||||
#include <ctype.h>
|
||||
#include <string.h>
|
||||
#include "common.h"
|
||||
|
||||
/*
|
||||
simple reader for /etc/hosts
|
||||
|
@ -24,7 +25,6 @@ void hostsreader_close(struct hostsreader *ctx) {
|
|||
fclose(ctx->f);
|
||||
}
|
||||
|
||||
static int isnumericipv4(const char* ipstring);
|
||||
int hostsreader_get(struct hostsreader *ctx, char* buf, size_t bufsize) {
|
||||
while(1) {
|
||||
if(!fgets(buf, bufsize, ctx->f)) return 0;
|
||||
|
@ -44,14 +44,14 @@ int hostsreader_get(struct hostsreader *ctx, char* buf, size_t bufsize) {
|
|||
l--;
|
||||
}
|
||||
if(!l || !*p) continue;
|
||||
ctx->name = buf;
|
||||
ctx->name = p;
|
||||
while(*p && !isspace(*p) && l) {
|
||||
p++;
|
||||
l--;
|
||||
}
|
||||
if(!l || !*p) continue;
|
||||
*p = 0;
|
||||
if(isnumericipv4(ctx->ip)) return 1;
|
||||
if(pc_isnumericipv4(ctx->ip)) return 1;
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -73,49 +73,24 @@ char* hostsreader_get_ip_for_name(const char* name, char* buf, size_t bufsize) {
|
|||
#include <netinet/in.h>
|
||||
#include <sys/socket.h>
|
||||
#include <arpa/inet.h>
|
||||
ip_type hostsreader_get_numeric_ip_for_name(const char* name) {
|
||||
ip_type4 hostsreader_get_numeric_ip_for_name(const char* name) {
|
||||
char *hres;
|
||||
char buf[320];
|
||||
if((hres = hostsreader_get_ip_for_name(name, buf, sizeof buf))) {
|
||||
struct in_addr c;
|
||||
inet_aton(hres, &c);
|
||||
ip_type res;
|
||||
ip_type4 res;
|
||||
memcpy(res.octet, &c.s_addr, 4);
|
||||
return res;
|
||||
} else return ip_type_invalid;
|
||||
} else return IPT4_INVALID;
|
||||
}
|
||||
|
||||
#ifdef HOSTSREADER_TEST
|
||||
int main() {
|
||||
#include "ip_type.c"
|
||||
int main(int a, char**b) {
|
||||
char buf[256];
|
||||
char * ret = hostsreader_get_ip_for_name("goo", buf, sizeof buf);
|
||||
if(a != 2) return 1;
|
||||
char * ret = hostsreader_get_ip_for_name(b[1], buf, sizeof buf);
|
||||
printf("%s\n", ret ? ret : "null");
|
||||
}
|
||||
#endif
|
||||
|
||||
/* isnumericipv4() taken from libulz */
|
||||
static int isnumericipv4(const char* ipstring) {
|
||||
size_t x = 0, n = 0, d = 0;
|
||||
int wasdot = 0;
|
||||
while(1) {
|
||||
switch(ipstring[x]) {
|
||||
case 0: goto done;
|
||||
case '.':
|
||||
if(!n || wasdot) return 0;
|
||||
d++;
|
||||
wasdot = 1;
|
||||
break;
|
||||
case '0': case '1': case '2': case '3': case '4':
|
||||
case '5': case '6': case '7': case '8': case '9':
|
||||
n++;
|
||||
wasdot = 0;
|
||||
break;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
x++;
|
||||
}
|
||||
done:
|
||||
if(d == 3 && n >= 4 && n <= 12) return 1;
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -1,5 +0,0 @@
|
|||
#include "ip_type.h"
|
||||
|
||||
const ip_type ip_type_invalid = { .as_int = -1 };
|
||||
const ip_type ip_type_localhost = { {127, 0, 0, 1} };
|
||||
|
|
@ -6,10 +6,20 @@
|
|||
typedef union {
|
||||
unsigned char octet[4];
|
||||
uint32_t as_int;
|
||||
} ip_type4;
|
||||
|
||||
typedef struct {
|
||||
union {
|
||||
ip_type4 v4;
|
||||
unsigned char v6[16];
|
||||
} addr;
|
||||
char is_v6;
|
||||
} ip_type;
|
||||
|
||||
extern const ip_type ip_type_invalid;
|
||||
extern const ip_type ip_type_localhost;
|
||||
#define IPT4_INT(X) (ip_type4){.as_int = (X)}
|
||||
#define IPT4_INVALID IPT4_INT(-1)
|
||||
|
||||
#define IPT4_BYTES(A,B,C,D) (ip_type4){.octet = {(A), (B), (C), (D)} }
|
||||
#define IPT4_LOCALHOST IPT4_BYTES(127,0,0,1)
|
||||
|
||||
//RcB: DEP "ip_type.c"
|
||||
#endif
|
||||
|
|
File diff suppressed because it is too large
Load Diff
38
src/main.c
38
src/main.c
|
@ -7,10 +7,7 @@
|
|||
* *
|
||||
***************************************************************************/
|
||||
|
||||
#undef _POSIX_C_SOURCE
|
||||
#define _POSIX_C_SOURCE 200809L
|
||||
#undef _XOPEN_SOURCE
|
||||
#define _XOPEN_SOURCE 700
|
||||
#define _DEFAULT_SOURCE
|
||||
#include <stdio.h>
|
||||
#include <unistd.h>
|
||||
#include <stdlib.h>
|
||||
|
@ -19,12 +16,17 @@
|
|||
#include <sys/types.h>
|
||||
#include <sys/wait.h>
|
||||
|
||||
#ifdef IS_MAC
|
||||
#define _DARWIN_C_SOURCE
|
||||
#endif
|
||||
#include <dlfcn.h>
|
||||
|
||||
#include "common.h"
|
||||
|
||||
static int usage(char **argv) {
|
||||
printf("\nUsage:\t%s -q -f config_file program_name [arguments]\n"
|
||||
"\t-q makes proxychains quiet - this overrides the config setting\n"
|
||||
"\t-f allows to manually specify a configfile to use\n"
|
||||
"\t-f allows one to manually specify a configfile to use\n"
|
||||
"\tfor example : proxychains telnet somehost.com\n" "More help in README file\n\n", argv[0]);
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
@ -49,7 +51,7 @@ static void set_own_dir(const char *argv0) {
|
|||
size_t l = strlen(argv0);
|
||||
while(l && argv0[l - 1] != '/')
|
||||
l--;
|
||||
if(l == 0)
|
||||
if(l == 0 || l >= sizeof(own_dir))
|
||||
#ifdef SUPER_SECURE
|
||||
memcpy(own_dir, "/dev/null/", 11);
|
||||
#else
|
||||
|
@ -72,6 +74,9 @@ int main(int argc, char *argv[]) {
|
|||
size_t i;
|
||||
const char *prefix = NULL;
|
||||
|
||||
if(argc == 2 && !strcmp(argv[1], "--help"))
|
||||
return usage(argv);
|
||||
|
||||
for(i = 0; i < MAX_COMMANDLINE_FLAGS; i++) {
|
||||
if(start_argv < argc && argv[start_argv][0] == '-') {
|
||||
if(argv[start_argv][1] == 'q') {
|
||||
|
@ -108,7 +113,9 @@ int main(int argc, char *argv[]) {
|
|||
|
||||
// search DLL
|
||||
|
||||
set_own_dir(argv[0]);
|
||||
Dl_info dli;
|
||||
dladdr(own_dir, &dli);
|
||||
set_own_dir(dli.dli_fname);
|
||||
|
||||
i = 0;
|
||||
|
||||
|
@ -128,16 +135,20 @@ int main(int argc, char *argv[]) {
|
|||
if(!quiet)
|
||||
fprintf(stderr, LOG_PREFIX "preloading %s/%s\n", prefix, dll_name);
|
||||
|
||||
#if defined(IS_MAC) || defined(IS_OPENBSD)
|
||||
#define LD_PRELOAD_SEP ":"
|
||||
#else
|
||||
/* Dynlinkers for Linux and most BSDs seem to support space
|
||||
as LD_PRELOAD separator, with colon added only recently.
|
||||
We use the old syntax for maximum compat */
|
||||
#define LD_PRELOAD_SEP " "
|
||||
#endif
|
||||
|
||||
#ifdef IS_MAC
|
||||
putenv("DYLD_FORCE_FLAT_NAMESPACE=1");
|
||||
#define LD_PRELOAD_ENV "DYLD_INSERT_LIBRARIES"
|
||||
#define LD_PRELOAD_SEP ":"
|
||||
#else
|
||||
#define LD_PRELOAD_ENV "LD_PRELOAD"
|
||||
/* all historic implementations of BSD and linux dynlinkers seem to support
|
||||
space as LD_PRELOAD separator, with colon added only recently.
|
||||
we use the old syntax for maximum compat */
|
||||
#define LD_PRELOAD_SEP " "
|
||||
#endif
|
||||
char *old_val = getenv(LD_PRELOAD_ENV);
|
||||
snprintf(buf, sizeof(buf), LD_PRELOAD_ENV "=%s/%s%s%s",
|
||||
|
@ -147,7 +158,8 @@ int main(int argc, char *argv[]) {
|
|||
old_val ? old_val : "");
|
||||
putenv(buf);
|
||||
execvp(argv[start_argv], &argv[start_argv]);
|
||||
perror("proxychains can't load process....");
|
||||
fprintf(stderr, "proxychains: can't load process '%s'.", argv[start_argv]);
|
||||
perror(" (hint: it's probably a typo)");
|
||||
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
|
|
@ -1,13 +0,0 @@
|
|||
#include <sys/socket.h>
|
||||
|
||||
extern int pc_getnameinfo(const void *sa, socklen_t salen,
|
||||
char *host, socklen_t hostlen, char *serv,
|
||||
socklen_t servlen, int flags);
|
||||
|
||||
|
||||
int getnameinfo(const void *sa, socklen_t salen,
|
||||
char *host, socklen_t hostlen, char *serv,
|
||||
socklen_t servlen, int flags) {
|
||||
return pc_getnameinfo(sa, salen, host, hostlen, serv, servlen, flags);
|
||||
}
|
||||
|
|
@ -48,9 +48,33 @@ strict_chain
|
|||
# Quiet mode (no output from library)
|
||||
#quiet_mode
|
||||
|
||||
# Proxy DNS requests - no leak for DNS data
|
||||
## Proxy DNS requests - no leak for DNS data
|
||||
# (disable all of the 3 items below to not proxy your DNS requests)
|
||||
|
||||
# method 1. this uses the proxychains4 style method to do remote dns:
|
||||
# a thread is spawned that serves DNS requests and hands down an ip
|
||||
# assigned from an internal list (via remote_dns_subnet).
|
||||
# this is the easiest (setup-wise) and fastest method, however on
|
||||
# systems with buggy libcs and very complex software like webbrowsers
|
||||
# this might not work and/or cause crashes.
|
||||
proxy_dns
|
||||
|
||||
# method 2. use the old proxyresolv script to proxy DNS requests
|
||||
# in proxychains 3.1 style. requires `proxyresolv` in $PATH
|
||||
# plus a dynamically linked `dig` binary.
|
||||
# this is a lot slower than `proxy_dns`, doesn't support .onion URLs,
|
||||
# but might be more compatible with complex software like webbrowsers.
|
||||
#proxy_dns_old
|
||||
|
||||
# method 3. use proxychains4-daemon process to serve remote DNS requests.
|
||||
# this is similar to the threaded `proxy_dns` method, however it requires
|
||||
# that proxychains4-daemon is already running on the specified address.
|
||||
# on the plus side it doesn't do malloc/threads so it should be quite
|
||||
# compatible with complex, async-unsafe software.
|
||||
# note that if you don't start proxychains4-daemon before using this,
|
||||
# the process will simply hang.
|
||||
#proxy_dns_daemon 127.0.0.1:1053
|
||||
|
||||
# set the class A subnet number to use for the internal remote DNS mapping
|
||||
# we use the reserved 224.x.x.x range by default,
|
||||
# if the proxified app does a DNS request, we will return an IP from that range.
|
||||
|
@ -70,6 +94,9 @@ tcp_connect_time_out 8000
|
|||
|
||||
### Examples for localnet exclusion
|
||||
## localnet ranges will *not* use a proxy to connect.
|
||||
## note that localnet works only when plain IP addresses are passed to the app,
|
||||
## the hostname resolves via /etc/hosts, or proxy_dns is disabled or proxy_dns_old used.
|
||||
|
||||
## Exclude connections to 192.168.1.0/24 with port 80
|
||||
# localnet 192.168.1.0:80/255.255.255.0
|
||||
|
||||
|
@ -78,18 +105,36 @@ tcp_connect_time_out 8000
|
|||
|
||||
## Exclude connections to ANYwhere with port 80
|
||||
# localnet 0.0.0.0:80/0.0.0.0
|
||||
# localnet [::]:80/0
|
||||
|
||||
## RFC5735 Loopback address range
|
||||
## RFC6890 Loopback address range
|
||||
## if you enable this, you have to make sure remote_dns_subnet is not 127
|
||||
## you'll need to enable it if you want to use an application that
|
||||
## connects to localhost.
|
||||
# localnet 127.0.0.0/255.0.0.0
|
||||
# localnet ::1/128
|
||||
|
||||
## RFC1918 Private Address Ranges
|
||||
# localnet 10.0.0.0/255.0.0.0
|
||||
# localnet 172.16.0.0/255.240.0.0
|
||||
# localnet 192.168.0.0/255.255.0.0
|
||||
|
||||
### Examples for dnat
|
||||
## Trying to proxy connections to destinations which are dnatted,
|
||||
## will result in proxying connections to the new given destinations.
|
||||
## Whenever I connect to 1.1.1.1 on port 1234 actually connect to 1.1.1.2 on port 443
|
||||
# dnat 1.1.1.1:1234 1.1.1.2:443
|
||||
|
||||
## Whenever I connect to 1.1.1.1 on port 443 actually connect to 1.1.1.2 on port 443
|
||||
## (no need to write :443 again)
|
||||
# dnat 1.1.1.2:443 1.1.1.2
|
||||
|
||||
## No matter what port I connect to on 1.1.1.1 port actually connect to 1.1.1.2 on port 443
|
||||
# dnat 1.1.1.1 1.1.1.2:443
|
||||
|
||||
## Always, instead of connecting to 1.1.1.1, connect to 1.1.1.2
|
||||
# dnat 1.1.1.1 1.1.1.2
|
||||
|
||||
# ProxyList format
|
||||
# type ip port [user pass]
|
||||
# (values separated by 'tab' or 'blank')
|
||||
|
@ -105,7 +150,8 @@ tcp_connect_time_out 8000
|
|||
# http 192.168.39.93 8080
|
||||
#
|
||||
#
|
||||
# proxy types: http, socks4, socks5
|
||||
# proxy types: http, socks4, socks5, raw
|
||||
# * raw: The traffic is simply forwarded to the proxy without modification.
|
||||
# ( auth types supported: "basic"-http "user/pass"-socks )
|
||||
#
|
||||
[ProxyList]
|
||||
|
|
|
@ -1,10 +1,8 @@
|
|||
#!/bin/sh
|
||||
# This is a legacy script that uses "dig" to do DNS lookups via TCP.
|
||||
# it is not actively maintained since proxychains no longer depends
|
||||
# on it. i leave it here as a bonus.
|
||||
# This is a legacy script that uses "dig" or "drill" to do DNS lookups via TCP.
|
||||
|
||||
# DNS server used to resolve names
|
||||
DNS_SERVER=8.8.8.8
|
||||
test -z "$DNS_SERVER" && DNS_SERVER=8.8.8.8
|
||||
|
||||
|
||||
if [ $# = 0 ] ; then
|
||||
|
@ -14,5 +12,12 @@ if [ $# = 0 ] ; then
|
|||
fi
|
||||
|
||||
|
||||
export LD_PRELOAD=libproxychains4.so
|
||||
dig $1 @$DNS_SERVER +tcp | awk '/A.?[0-9]+\.[0-9]+\.[0-9]/{print $5;}'
|
||||
test -z $LD_PRELOAD && export LD_PRELOAD=libproxychains4.so
|
||||
|
||||
if type dig 1>/dev/null 2>&1 ; then
|
||||
dig $1 @$DNS_SERVER +tcp | awk '/A.?[0-9]+\.[0-9]+\.[0-9]/{print $5;}'
|
||||
elif type drill 1>/dev/null 2>&1 ; then
|
||||
drill -t4 $1 @$DNS_SERVER | awk '/A.+[0-9]+\.[0-9]+\.[0-9]/{print $5;}'
|
||||
else
|
||||
echo "error: neither dig nor drill found" >&2
|
||||
fi
|
||||
|
|
|
@ -0,0 +1,99 @@
|
|||
#include <sys/socket.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "rdns.h"
|
||||
#include "allocator_thread.h"
|
||||
#include "remotedns.h"
|
||||
|
||||
#ifndef HAVE_SOCK_CLOEXEC
|
||||
#define SOCK_CLOEXEC 0
|
||||
#endif
|
||||
|
||||
//static enum dns_lookup_flavor dns_flavor;
|
||||
#define dns_flavor rdns_get_flavor()
|
||||
|
||||
static struct sockaddr_in rdns_server;
|
||||
|
||||
size_t rdns_daemon_get_host_for_ip(ip_type4 ip, char* readbuf) {
|
||||
struct at_msg msg = {
|
||||
.h.msgtype = ATM_GETNAME,
|
||||
.h.datalen = htons(4),
|
||||
.m.ip = ip,
|
||||
};
|
||||
int fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
|
||||
sendto(fd, &msg, sizeof(msg.h)+4, 0, (void*)&rdns_server, sizeof(rdns_server));
|
||||
recvfrom(fd, &msg, sizeof msg, 0, (void*)0, (void*)0);
|
||||
close(fd);
|
||||
msg.h.datalen = ntohs(msg.h.datalen);
|
||||
if(!msg.h.datalen || msg.h.datalen > 256) return 0;
|
||||
memcpy(readbuf, msg.m.host, msg.h.datalen);
|
||||
return msg.h.datalen - 1;
|
||||
}
|
||||
|
||||
static ip_type4 rdns_daemon_get_ip_for_host(char* host, size_t len) {
|
||||
struct at_msg msg = {
|
||||
.h.msgtype = ATM_GETIP,
|
||||
};
|
||||
if(len >= 256) return IPT4_INT(-1);
|
||||
memcpy(msg.m.host, host, len+1);
|
||||
msg.h.datalen = htons(len+1);
|
||||
int fd = socket(AF_INET, SOCK_DGRAM|SOCK_CLOEXEC, 0);
|
||||
sendto(fd, &msg, sizeof(msg.h)+len+1, 0, (void*)&rdns_server, sizeof(rdns_server));
|
||||
recvfrom(fd, &msg, sizeof msg, 0, (void*)0, (void*)0);
|
||||
close(fd);
|
||||
if(ntohs(msg.h.datalen) != 4) return IPT4_INT(-1);
|
||||
return msg.m.ip;
|
||||
}
|
||||
|
||||
const char *rdns_resolver_string(enum dns_lookup_flavor flavor) {
|
||||
static const char tab[][7] = {
|
||||
[DNSLF_LIBC] = "off",
|
||||
[DNSLF_FORKEXEC] = "old",
|
||||
[DNSLF_RDNS_THREAD] = "thread",
|
||||
[DNSLF_RDNS_DAEMON] = "daemon",
|
||||
};
|
||||
return tab[flavor];
|
||||
}
|
||||
|
||||
void rdns_init(enum dns_lookup_flavor flavor) {
|
||||
static int init_done = 0;
|
||||
if(!init_done) switch(flavor) {
|
||||
case DNSLF_RDNS_THREAD:
|
||||
at_init();
|
||||
break;
|
||||
case DNSLF_RDNS_DAEMON:
|
||||
default:
|
||||
break;
|
||||
}
|
||||
init_done = 1;
|
||||
}
|
||||
|
||||
void rdns_set_daemon(struct sockaddr_in* addr) {
|
||||
rdns_server = *addr;
|
||||
}
|
||||
|
||||
#if 0
|
||||
enum dns_lookup_flavor rdns_get_flavor(void) {
|
||||
return dns_flavor;
|
||||
}
|
||||
#endif
|
||||
|
||||
size_t rdns_get_host_for_ip(ip_type4 ip, char* readbuf) {
|
||||
switch(dns_flavor) {
|
||||
case DNSLF_RDNS_THREAD: return at_get_host_for_ip(ip, readbuf);
|
||||
case DNSLF_RDNS_DAEMON: return rdns_daemon_get_host_for_ip(ip, readbuf);
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
||||
ip_type4 rdns_get_ip_for_host(char* host, size_t len) {
|
||||
switch(dns_flavor) {
|
||||
case DNSLF_RDNS_THREAD: return at_get_ip_for_host(host, len);
|
||||
case DNSLF_RDNS_DAEMON: return rdns_daemon_get_ip_for_host(host, len);
|
||||
default:
|
||||
abort();
|
||||
}
|
||||
}
|
||||
|
|
@ -0,0 +1,28 @@
|
|||
#ifndef RDNS_H
|
||||
#define RDNS_H
|
||||
|
||||
#include <unistd.h>
|
||||
#include <netinet/in.h>
|
||||
#include "ip_type.h"
|
||||
#include "remotedns.h"
|
||||
|
||||
enum dns_lookup_flavor {
|
||||
DNSLF_LIBC = 0,
|
||||
DNSLF_FORKEXEC,
|
||||
|
||||
DNSLF_RDNS_START,
|
||||
DNSLF_RDNS_THREAD = DNSLF_RDNS_START,
|
||||
DNSLF_RDNS_DAEMON,
|
||||
};
|
||||
|
||||
void rdns_init(enum dns_lookup_flavor flavor);
|
||||
void rdns_set_daemon(struct sockaddr_in* addr);
|
||||
const char *rdns_resolver_string(enum dns_lookup_flavor flavor);
|
||||
size_t rdns_get_host_for_ip(ip_type4 ip, char* readbuf);
|
||||
ip_type4 rdns_get_ip_for_host(char* host, size_t len);
|
||||
|
||||
//enum dns_lookup_flavor rdns_get_flavor(void);
|
||||
#define rdns_get_flavor() proxychains_resolver
|
||||
extern enum dns_lookup_flavor proxychains_resolver;
|
||||
|
||||
#endif
|
|
@ -0,0 +1,31 @@
|
|||
#ifndef REMOTEDNS_H
|
||||
#define REMOTEDNS_H
|
||||
|
||||
#include <unistd.h>
|
||||
#include "ip_type.h"
|
||||
|
||||
#define MSG_LEN_MAX 256
|
||||
|
||||
enum at_msgtype {
|
||||
ATM_GETIP = 0,
|
||||
ATM_GETNAME,
|
||||
ATM_FAIL,
|
||||
ATM_EXIT,
|
||||
};
|
||||
|
||||
struct at_msghdr {
|
||||
unsigned char msgtype; /* at_msgtype */
|
||||
char reserved;
|
||||
unsigned short datalen;
|
||||
};
|
||||
|
||||
struct at_msg {
|
||||
struct at_msghdr h;
|
||||
union {
|
||||
char host[260];
|
||||
ip_type4 ip;
|
||||
} m;
|
||||
};
|
||||
|
||||
#endif
|
||||
|
53
src/shm.c
53
src/shm.c
|
@ -1,53 +0,0 @@
|
|||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <limits.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#ifndef PAGE_SIZE
|
||||
#define PAGE_SIZE 4096
|
||||
#endif
|
||||
#include "shm.h"
|
||||
#include "debug.h"
|
||||
|
||||
#if 0
|
||||
#include <sys/mman.h>
|
||||
#include <sys/ipc.h>
|
||||
#include <sys/shm.h>
|
||||
|
||||
/* allocates shared memory which can be accessed from the parent and its childs */
|
||||
void *shm_realloc(void* old, size_t old_size, size_t new_size) {
|
||||
//PFUNC();
|
||||
void *nu = mmap(NULL, new_size, PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANON, -1, 0);
|
||||
if(old) {
|
||||
if(!nu) return NULL;
|
||||
assert(new_size >= old_size);
|
||||
memcpy(nu, old, old_size);
|
||||
munmap(old, old_size);
|
||||
}
|
||||
return nu;
|
||||
}
|
||||
#endif
|
||||
|
||||
void stringpool_init(struct stringpool* sp) {
|
||||
PFUNC();
|
||||
memset(sp, 0, sizeof *sp);
|
||||
}
|
||||
|
||||
char* stringpool_add(struct stringpool *sp, char* s, size_t len) {
|
||||
//PFUNC();
|
||||
if(len > sp->alloced - sp->used) {
|
||||
size_t newsz = sp->used + len;
|
||||
size_t inc = PAGE_SIZE - (newsz % PAGE_SIZE);
|
||||
newsz += (inc == PAGE_SIZE) ? 0 : inc;
|
||||
void* p = realloc(sp->start, newsz);
|
||||
if(p) {
|
||||
sp->start = p;
|
||||
sp->alloced = newsz;
|
||||
} else
|
||||
return 0;
|
||||
}
|
||||
char* ret = sp->start + sp->used;
|
||||
memcpy(ret, s, len);
|
||||
sp->used += len;
|
||||
return ret;
|
||||
}
|
17
src/shm.h
17
src/shm.h
|
@ -1,17 +0,0 @@
|
|||
#ifndef SHM_H
|
||||
#define SHM_H
|
||||
#include <unistd.h>
|
||||
|
||||
struct stringpool {
|
||||
size_t alloced;
|
||||
size_t used;
|
||||
char* start;
|
||||
};
|
||||
|
||||
void stringpool_init(struct stringpool* sp);
|
||||
char* stringpool_add(struct stringpool *sp, char* s, size_t len);
|
||||
#if 0
|
||||
void *shm_realloc(void* old, size_t old_size, size_t new_size);
|
||||
#endif
|
||||
//RcB: DEP "shm.c"
|
||||
#endif
|
|
@ -1,13 +0,0 @@
|
|||
#include "stringdump.h"
|
||||
#include "debug.h"
|
||||
|
||||
struct stringpool mem;
|
||||
|
||||
char *dumpstring(char* s, size_t len) {
|
||||
PFUNC();
|
||||
return stringpool_add(&mem, s, len);
|
||||
}
|
||||
|
||||
void dumpstring_init(void) {
|
||||
stringpool_init(&mem);
|
||||
}
|
|
@ -1,12 +0,0 @@
|
|||
#ifndef STRINGDUMP_H
|
||||
#define STRINGDUMP_H
|
||||
|
||||
#include "shm.h"
|
||||
#include <unistd.h>
|
||||
|
||||
char *dumpstring(char* s, size_t len);
|
||||
void dumpstring_init(void);
|
||||
|
||||
//RcB: DEP "stringdump.h"
|
||||
|
||||
#endif
|
|
@ -3,18 +3,20 @@
|
|||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
#include <sys/socket.h>
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
|
||||
#ifndef NI_MAXHOST
|
||||
#define NI_MAXHOST 1025
|
||||
#endif
|
||||
|
||||
int main(void) {
|
||||
static int doit(const char* host, const char* service) {
|
||||
struct addrinfo *result;
|
||||
struct addrinfo *res;
|
||||
int error;
|
||||
|
||||
/* resolve the domain name into a list of addresses */
|
||||
error = getaddrinfo("www.example.com", NULL, NULL, &result);
|
||||
error = getaddrinfo(host, service, NULL, &result);
|
||||
if (error != 0)
|
||||
{
|
||||
fprintf(stderr, "error in getaddrinfo: %s\n", gai_strerror(error));
|
||||
|
@ -32,10 +34,53 @@ int main(void) {
|
|||
fprintf(stderr, "error in getnameinfo: %s\n", gai_strerror(error));
|
||||
continue;
|
||||
}
|
||||
if (*hostname != '\0')
|
||||
printf("hostname: %s\n", hostname);
|
||||
int port = 0;
|
||||
if(res->ai_family == AF_INET) port = ((struct sockaddr_in*)res->ai_addr)->sin_port;
|
||||
else if(res->ai_family == AF_INET6) port = ((struct sockaddr_in6*)res->ai_addr)->sin6_port;
|
||||
port = ntohs(port);
|
||||
printf("hostname: %s, port: %d\n", hostname, port);
|
||||
}
|
||||
|
||||
freeaddrinfo(result);
|
||||
return EXIT_SUCCESS;
|
||||
}
|
||||
|
||||
/* reproduce use of getaddrinfo as used by nmap 7.91's canonicalize_address */
|
||||
int canonicalize_address(struct sockaddr_storage *ss, struct sockaddr_storage *output) {
|
||||
char canonical_ip_string[NI_MAXHOST];
|
||||
struct addrinfo *ai;
|
||||
int rc;
|
||||
/* Convert address to string. */
|
||||
rc = getnameinfo((struct sockaddr *) ss, sizeof(*ss),
|
||||
canonical_ip_string, sizeof(canonical_ip_string), NULL, 0, NI_NUMERICHOST);
|
||||
assert(rc == 0);
|
||||
struct addrinfo hints = {
|
||||
.ai_family = ss->ss_family,
|
||||
.ai_socktype = SOCK_DGRAM,
|
||||
.ai_flags = AI_NUMERICHOST,
|
||||
};
|
||||
rc = getaddrinfo(canonical_ip_string, NULL, &hints, &ai);
|
||||
if (rc != 0 || ai == NULL)
|
||||
return -1;
|
||||
assert(ai->ai_addrlen > 0 && ai->ai_addrlen <= (int) sizeof(*output));
|
||||
memcpy(output, ai->ai_addr, ai->ai_addrlen);
|
||||
freeaddrinfo(ai);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
int ret;
|
||||
ret = doit("www.example.com", NULL);
|
||||
ret = doit("www.example.com", "80");
|
||||
struct sockaddr_storage o, ss = {.ss_family = PF_INET};
|
||||
struct sockaddr_in *v4 = &ss;
|
||||
struct sockaddr_in6 *v6 = &ss;
|
||||
memcpy(&v4->sin_addr, "\x7f\0\0\1", 4);
|
||||
ret = canonicalize_address(&ss, &o);
|
||||
assert (ret == 0);
|
||||
ss.ss_family = PF_INET6;
|
||||
memcpy(&v6->sin6_addr, "\0\0\0\0" "\0\0\0\0" "\0\0\0\0""\0\0\0\1", 16);
|
||||
ret = canonicalize_address(&ss, &o);
|
||||
assert (ret == 0);
|
||||
return ret;
|
||||
}
|
||||
|
|
|
@ -0,0 +1,23 @@
|
|||
#include <stdio.h>
|
||||
#include <netdb.h>
|
||||
#include "../src/common.c"
|
||||
|
||||
void printhostent(struct hostent *hp) {
|
||||
char ipbuf[16];
|
||||
pc_stringfromipv4(hp->h_addr_list[0], ipbuf);
|
||||
printf("alias: %p, len: %d, name: %s, addrlist: %p, addrtype: %d, ip: %s\n",
|
||||
hp->h_aliases,
|
||||
hp->h_length,
|
||||
hp->h_name,
|
||||
hp->h_addr_list,
|
||||
hp->h_addrtype,
|
||||
ipbuf
|
||||
);
|
||||
}
|
||||
int main(int argc, char**argv) {
|
||||
struct hostent* ret;
|
||||
if(argc == 1) return 1;
|
||||
ret = gethostbyname(argv[1]);
|
||||
if(ret) printhostent(ret);
|
||||
return 0;
|
||||
}
|
|
@ -1,6 +1,6 @@
|
|||
#include <netdb.h>
|
||||
#include <stdio.h>
|
||||
#include "../src/common.h"
|
||||
#include "../src/common.c"
|
||||
|
||||
void printhostent(struct hostent *hp) {
|
||||
char ipbuf[16];
|
||||
|
|
|
@ -11,73 +11,129 @@
|
|||
#define SOCKPORT(x) (satosin(x)->sin_port)
|
||||
#define SOCKFAMILY(x) (satosin(x)->sin_family)
|
||||
|
||||
#define ASSERT(X) { if(!(X)) printf("ASSERTION FAILED: %s @%s:%d\n", # X, __FILE__, __LINE__); }
|
||||
#define CLR() { hbuf[0] = 0; sbuf[0] = 0; }
|
||||
|
||||
int main() {
|
||||
struct sockaddr a = {0}, *sa = &a;
|
||||
struct sockaddr_in a = {0}, *sa = &a;
|
||||
char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
|
||||
SOCKPORT(a) = htons(80);
|
||||
memcpy( &( (struct sockaddr_in*) sa ) ->sin_addr , (char[]) {127,0,0,1}, 4);
|
||||
a.sin_port = htons(80);
|
||||
memcpy( &a.sin_addr , (char[]) {127,0,0,1}, 4);
|
||||
|
||||
int ret;
|
||||
|
||||
if ((ret = getnameinfo(sa, 0, hbuf, sizeof(hbuf), sbuf,
|
||||
if ((ret = getnameinfo((void*)sa, 0, hbuf, sizeof(hbuf), sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
assert(ret == EAI_FAMILY);
|
||||
ASSERT(ret == EAI_FAMILY);
|
||||
CLR();
|
||||
|
||||
if ((ret = getnameinfo(sa, sizeof a, hbuf, sizeof(hbuf), sbuf,
|
||||
if ((ret = getnameinfo((void*)sa, sizeof a, hbuf, sizeof(hbuf), sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
assert(ret == EAI_FAMILY);
|
||||
ASSERT(ret == EAI_FAMILY);
|
||||
CLR();
|
||||
|
||||
SOCKFAMILY(a) = AF_INET;
|
||||
|
||||
if ((ret = getnameinfo(sa, sizeof a, hbuf, 1, sbuf,
|
||||
if ((ret = getnameinfo((void*)sa, sizeof a, hbuf, 1, sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
assert(ret == EAI_OVERFLOW);
|
||||
ASSERT(ret == EAI_OVERFLOW);
|
||||
CLR();
|
||||
|
||||
if ((ret = getnameinfo(sa, sizeof a, hbuf, 0, sbuf,
|
||||
if ((ret = getnameinfo((void*)sa, sizeof a, hbuf, 0, sbuf,
|
||||
1, NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
assert(ret == EAI_OVERFLOW);
|
||||
ASSERT(ret == EAI_OVERFLOW);
|
||||
CLR();
|
||||
|
||||
if ((ret = getnameinfo(sa, sizeof a, hbuf, 0, sbuf,
|
||||
if ((ret = getnameinfo((void*)sa, sizeof(a) - 1, hbuf, 0, sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
assert(ret == 0);
|
||||
ASSERT(ret == EAI_FAMILY);
|
||||
CLR();
|
||||
|
||||
if ((ret = getnameinfo(sa, sizeof a, hbuf, sizeof hbuf, sbuf,
|
||||
if ((ret = getnameinfo((void*)sa, sizeof a, hbuf, 0, sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
ASSERT(ret == 0 && !strcmp("80", sbuf));
|
||||
CLR();
|
||||
|
||||
if ((ret = getnameinfo((void*)sa, sizeof a, hbuf, sizeof hbuf, sbuf,
|
||||
0, NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
assert(ret == 0);
|
||||
ASSERT(ret == 0 && !strcmp("127.0.0.1",hbuf));
|
||||
CLR();
|
||||
|
||||
|
||||
if ((ret = getnameinfo(sa, sizeof a, hbuf, sizeof(hbuf), sbuf,
|
||||
if ((ret = getnameinfo((void*)sa, sizeof a, hbuf, sizeof(hbuf), sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
assert(ret == 0);
|
||||
ASSERT(ret == 0 && !strcmp("127.0.0.1",hbuf) && !strcmp("80", sbuf));
|
||||
CLR();
|
||||
|
||||
struct sockaddr_in6 b = {0}, *sb = &b;
|
||||
b.sin6_port = htons(8080);
|
||||
b.sin6_family = AF_INET6;
|
||||
|
||||
memcpy(&b.sin6_addr,"\0\0\0\0\0\0\0\0\0\0\xff\xff\xc0\xa8\1\2", 16);
|
||||
|
||||
if ((ret = getnameinfo((void*)sb, sizeof b, hbuf, sizeof(hbuf), sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
ASSERT(ret == 0 && !strcmp("192.168.1.2",hbuf) && !strcmp("8080", sbuf));
|
||||
CLR();
|
||||
|
||||
b.sin6_scope_id = 3;
|
||||
memcpy(&b.sin6_addr,"\0\0\xaa\0\0\0\0\0\0\0\0\xff\xc0\xa8\1\2", 16);
|
||||
|
||||
if ((ret = getnameinfo((void*)sb, sizeof b, hbuf, sizeof(hbuf), sbuf,
|
||||
sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV | NI_NUMERICSCOPE)) == 0)
|
||||
printf("host=%s, serv=%s\n", hbuf, sbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
ASSERT(ret == 0);
|
||||
|
||||
b.sin6_port = 0;
|
||||
b.sin6_scope_id = 0;
|
||||
memcpy(&b.sin6_addr,"\0\0\0\0" "\0\0\0\0" "\0\0\0\0" "\0\0\0\1", 16);
|
||||
|
||||
if ((ret = getnameinfo((void*)sb, sizeof b, hbuf, sizeof(hbuf), NULL,
|
||||
0, NI_NUMERICHOST)) == 0)
|
||||
printf("host=%s\n", hbuf);
|
||||
else
|
||||
printf("%s\n", gai_strerror(ret));
|
||||
|
||||
ASSERT(ret == 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -0,0 +1,42 @@
|
|||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <netdb.h>
|
||||
#include <netinet/in.h>
|
||||
#include <sys/socket.h>
|
||||
|
||||
static void v4_to_v6(const struct in_addr *v4, struct in6_addr *v6) {
|
||||
memset(v6, 0, sizeof(*v6));
|
||||
v6->s6_addr[10]=0xff;
|
||||
v6->s6_addr[11]=0xff;
|
||||
memcpy(&v6->s6_addr[12], &v4->s_addr, 4);
|
||||
}
|
||||
|
||||
int main(void) {
|
||||
struct addrinfo *result;
|
||||
struct addrinfo *res;
|
||||
const struct addrinfo hints = { .ai_family = AF_INET };
|
||||
int error, sock;
|
||||
|
||||
/* resolve the domain name into a list of addresses */
|
||||
error = getaddrinfo("www.example.com", NULL, &hints, &result);
|
||||
if (error != 0) {
|
||||
fprintf(stderr, "error in getaddrinfo: %s\n", gai_strerror(error));
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
if((sock=socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) == -1) {
|
||||
perror("socket");
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
struct sockaddr_in6 a = { .sin6_family = AF_INET6,
|
||||
.sin6_port = htons(80) };
|
||||
v4_to_v6(&((struct sockaddr_in *)result->ai_addr)->sin_addr, &a.sin6_addr);
|
||||
freeaddrinfo(result);
|
||||
|
||||
if((error = connect(sock, (struct sockaddr *)&a, sizeof(a))) == -1) {
|
||||
perror("connect");
|
||||
return EXIT_FAILURE;
|
||||
}
|
||||
|
||||
return EXIT_SUCCESS;
|
||||
}
|
Loading…
Reference in New Issue