mirror of
https://github.com/wangyu-/udp2raw.git
synced 2024-06-16 12:09:18 +00:00
Compare commits
61 Commits
20181113.0
...
unified
| Author | SHA1 | Date | |
|---|---|---|---|
|
4623f878e0 | ||
|
|
e42f0e5732 | ||
|
|
f49e6adedf | ||
|
|
d1a9bcc4fb | ||
|
|
bc8bd8c2f8 | ||
|
|
ca16c3a5e6 | ||
|
|
7abe19c7d9 | ||
|
|
f3f528e866 | ||
|
|
ec6fad552b | ||
|
|
87b878a09e | ||
|
|
e66eddd1d5 | ||
|
|
ec416515f3 | ||
|
|
d12e540830 | ||
|
|
e7eecc8ef2 | ||
|
|
82ba4f7d1b | ||
|
|
e5ecd33ec4 | ||
|
|
9217e0e9e6 | ||
|
|
87b0db8862 | ||
|
|
8ceaf27eda | ||
|
|
9f9e8caff6 | ||
|
|
74f3eb90a7 | ||
|
|
38286d5c5b | ||
|
|
ec849322d7 | ||
|
|
b98a467eed | ||
|
|
25d3323427 | ||
|
|
b8e9095135 | ||
|
|
026f97687a | ||
|
|
f2f90a9a15 | ||
|
|
cf23f4d656 | ||
|
|
59819db2dd | ||
|
|
cc6ea766c4 | ||
|
|
509156fc14 | ||
|
|
cb9059bf3b | ||
|
|
07e2e695a6 | ||
|
|
e8daf7c263 | ||
|
|
5f907e32d7 | ||
|
|
0e37c1fea4 | ||
|
|
606bbec351 | ||
|
|
3fc23f5cf6 | ||
|
|
f3c8f70f47 | ||
|
|
6c27502757 | ||
|
|
5a51248cb0 | ||
|
|
79bb28fd12 | ||
|
|
b3e06de4cb | ||
|
|
b03ae53df6 | ||
|
|
15c15d5bcb | ||
|
|
2f0328a41a | ||
|
|
779ebdd37a | ||
|
|
5340f0726e | ||
|
|
e95ee70351 | ||
|
|
5cc304a261 | ||
|
|
7636225414 | ||
|
|
f68c6e211d | ||
|
|
8c81f7673b | ||
|
|
c1dfd4e928 | ||
|
|
7e55b1e132 | ||
|
|
ee787e0d4a | ||
|
|
7d481d26b9 | ||
|
|
168ae1e2ae | ||
|
|
6230569bbb | ||
|
|
238e85a5e4 |
4
.clang-format
Normal file
4
.clang-format
Normal file
@ -0,0 +1,4 @@
|
||||
SortIncludes: false
|
||||
BasedOnStyle: Google
|
||||
ColumnLimit: 0
|
||||
IndentWidth: 4
|
||||
35
CMakeLists.txt
Normal file
35
CMakeLists.txt
Normal file
@ -0,0 +1,35 @@
|
||||
#note: experimental
|
||||
# currently only used for generating `compile_commands.json` for clangd.
|
||||
# to build this project, it's suggested to use `makefile` instead
|
||||
|
||||
cmake_minimum_required(VERSION 3.7)
|
||||
project(udp2raw)
|
||||
set(CMAKE_EXPORT_COMPILE_COMMANDS ON)
|
||||
|
||||
set(CMAKE_CXX_STANDARD 11)
|
||||
|
||||
set(SOURCE_FILES
|
||||
main.cpp
|
||||
lib/md5.cpp
|
||||
lib/pbkdf2-sha1.cpp
|
||||
lib/pbkdf2-sha256.cpp
|
||||
encrypt.cpp
|
||||
log.cpp
|
||||
network.cpp
|
||||
common.cpp
|
||||
connection.cpp
|
||||
misc.cpp
|
||||
fd_manager.cpp
|
||||
client.cpp
|
||||
server.cpp
|
||||
lib/aes_faster_c/aes.cpp
|
||||
lib/aes_faster_c/wrapper.cpp
|
||||
my_ev.cpp
|
||||
)
|
||||
set(CMAKE_CXX_FLAGS "-Wall -Wextra -Wno-unused-variable -Wno-unused-parameter -Wno-missing-field-initializers -O2 -g -fsanitize=address,undefined")
|
||||
|
||||
add_executable(udp2raw ${SOURCE_FILES})
|
||||
target_link_libraries(udp2raw rt)
|
||||
target_link_libraries(udp2raw pthread)
|
||||
include_directories(SYSTEM "libev")
|
||||
include_directories(".")
|
||||
13
Dockerfile
13
Dockerfile
@ -1,13 +0,0 @@
|
||||
FROM alpine:3.6 as builder
|
||||
|
||||
WORKDIR /
|
||||
|
||||
RUN apk add --no-cache git build-base linux-headers && \
|
||||
git clone https://github.com/wangyu-/udp2raw-tunnel.git && \
|
||||
cd udp2raw-tunnel && \
|
||||
make dynamic
|
||||
|
||||
FROM alpine:3.6
|
||||
RUN apk add --no-cache libstdc++ iptables
|
||||
COPY --from=builder /udp2raw-tunnel/udp2raw_dynamic /bin/
|
||||
ENTRYPOINT [ "/bin/udp2raw_dynamic" ]
|
||||
@ -1,6 +1 @@
|
||||
For English speaking user：
|
||||
https://github.com/wangyu-/UDPspeeder/wiki/Issue-Guide
|
||||
|
||||
中文用户请看：
|
||||
https://github.com/wangyu-/UDPspeeder/wiki/发Issue前请看
|
||||
(否则Issue可能被忽略，或被直接关掉)
|
||||
English Only.
|
||||
|
||||
107
README.md
107
README.md
@ -1,43 +1,45 @@
|
||||
# Udp2raw-tunnel
|
||||
|
||||
|
||||
A Tunnel which turns UDP Traffic into Encrypted FakeTCP/UDP/ICMP Traffic by using Raw Socket, helps you Bypass UDP FireWalls(or Unstable UDP Environment). It can defend Replay-Attack and supports Multiplexing. It also acts as a Connection Stabilizer.
|
||||
A Tunnel which turns UDP Traffic into Encrypted FakeTCP/UDP/ICMP Traffic by using Raw Socket, helps you Bypass UDP FireWalls(or Unstable UDP Environment).
|
||||
|
||||
When used alone,udp2raw tunnels only UDP traffic. Nevertheless,if you used udp2raw + any UDP-based VPN together,you can tunnel any traffic(include TCP/UDP/ICMP),currently OpenVPN/L2TP/ShadowVPN and [tinyfecVPN](https://github.com/wangyu-/tinyfecVPN) are confirmed to be supported.
|
||||
|
||||
|
||||
|
||||
|
||||
When used alone,udp2raw tunnels only UDP traffic. Nevertheless,if you used udp2raw + any UDP-based VPN together,you can tunnel any traffic(include TCP/UDP/ICMP),currently OpenVPN/L2TP/ShadowVPN and [tinyfecVPN](https://github.com/wangyu-/tinyfecVPN) are confirmed to be supported.
|
||||
or
|
||||
|
||||
|
||||
|
||||
[简体中文](/doc/README.zh-cn.md)(内容更丰富)
|
||||
|
||||
[udp2raw wiki](https://github.com/wangyu-/udp2raw-tunnel/wiki)
|
||||
|
||||
[简体中文](/doc/README.zh-cn.md)
|
||||
|
||||
|
||||
# Support Platforms
|
||||
Linux host (including desktop Linux,Android phone/tablet,OpenWRT router,or Raspberry PI) with root access.
|
||||
Linux host (including desktop Linux,Android phone/tablet,OpenWRT router,or Raspberry PI) with root account or cap_net_raw capability.
|
||||
|
||||
For Windows and MacOS users, use the udp2raw in [this repo](https://github.com/wangyu-/udp2raw-multiplatform).
|
||||
|
||||
<del>For Windows and MacOS You can run udp2raw inside [this](https://github.com/wangyu-/udp2raw-tunnel/releases/download/20171108.0/lede-17.01.2-x86_virtual_machine_image.zip) 7.5mb virtual machine image(make sure network adapter runs at bridged mode).</del>
|
||||
|
||||
|
||||
|
||||
# Features
|
||||
# Features
|
||||
### Send/Receive UDP Packets with ICMP/FakeTCP/UDP headers
|
||||
ICMP/FakeTCP headers help you bypass UDP blocking, UDP QOS or improper UDP NAT behavior on some ISPs. In ICMP header mode,udp2raw works like an ICMP tunnel.
|
||||
ICMP/FakeTCP headers help you bypass UDP blocking, UDP QOS or improper UDP NAT behavior on some ISPs. In ICMP header mode,udp2raw works like an ICMP tunnel.
|
||||
|
||||
UDP headers are also supported. In UDP header mode, it behaves just like a normal UDP tunnel, and you can just make use of the other features (such as encrytion, anti-replay, or connection stalization).
|
||||
UDP headers are also supported. In UDP header mode, it behaves just like a normal UDP tunnel, and you can just make use of the other features (such as encryption, anti-replay, or connection stabilization).
|
||||
|
||||
### Simulated TCP with Real-time/Out-of-Order Delivery
|
||||
In FakeTCP header mode,udp2raw simulates 3-way handshake while establishing a connection,simulates seq and ack_seq while data transferring. It also simulates following TCP options: `MSS`, `sackOk`, `TS`, `TS_ack`, `wscale`.Firewalls will regard FakeTCP as a TCP connection, but its essentially UDP: it supports real-time/out-of-order delivery(just as normal UDP does), no congestion control or re-transmission. So there wont be any TCP over TCP problem when using OpenVPN.
|
||||
In FakeTCP header mode,udp2raw simulates 3-way handshake while establishing a connection,simulates seq and ack_seq while data transferring. It also simulates a few TCP options such as: `MSS`, `sackOk`, `TS`, `TS_ack`, `wscale`. Firewalls will regard FakeTCP as a TCP connection, but its essentially UDP: it supports real-time/out-of-order delivery(just as normal UDP does), no congestion control or re-transmission. So there wont be any TCP over TCP problem when using OpenVPN.
|
||||
|
||||
### Encryption, Anti-Replay
|
||||
* Encrypt your traffic with AES-128-CBC.
|
||||
* Protect data integrity by HMAC-SHA1 (or weaker MD5/CRC32).
|
||||
* Defense replay attack with an anti-replay window, smiliar to IPSec and OpenVPN.
|
||||
* Defense replay attack with anti-replay window.
|
||||
|
||||
### Failure Dectection & Stablization (Connection Recovery)
|
||||
Conection failures are detected by heartbeats. If timed-out, client will automatically change port number and reconnect. If reconnection is successful, the previous connection will be recovered, and all existing UDP conversations will stay vaild.
|
||||
[Notes on encryption](https://github.com/wangyu-/udp2raw-tunnel/wiki/Notes-on-encryption)
|
||||
|
||||
### Failure Dectection & Stabilization (Connection Recovery)
|
||||
Conection failures are detected by heartbeats. If timed-out, client will automatically change port number and reconnect. If reconnection is successful, the previous connection will be recovered, and all existing UDP conversations will stay vaild.
|
||||
|
||||
For example, if you use udp2raw + OpenVPN, OpenVPN won't lose connection after any reconnect, **even if network cable is re-plugged or WiFi access point is changed**.
|
||||
|
||||
@ -59,7 +61,7 @@ For example, if you use udp2raw + OpenVPN, OpenVPN won't lose connection after a
|
||||
### Installing
|
||||
Download binary release from https://github.com/wangyu-/udp2raw-tunnel/releases
|
||||
|
||||
### Running
|
||||
### Running
|
||||
Assume your UDP is blocked or being QOS-ed or just poorly supported. Assume your server ip is 44.55.66.77, you have a service listening on udp port 7777.
|
||||
|
||||
```bash
|
||||
@ -79,9 +81,9 @@ Assume your UDP is blocked or being QOS-ed or just poorly supported. Assume your
|
||||
Now,an encrypted raw tunnel has been established between client and server through TCP port 4096. Connecting to UDP port 3333 at the client side is equivalent to connecting to port 7777 at the server side. No UDP traffic will be exposed.
|
||||
|
||||
### Note
|
||||
To run on Android, check [Android_Guide](/doc/android_guide.md)
|
||||
To run on Android, check [Android_Guide](https://github.com/wangyu-/udp2raw/wiki/Android-Guide)
|
||||
|
||||
`-a` option automatically adds an iptables rule (or a few iptables rules) for you, udp2raw relys on this iptables rule to work stably. Be aware you dont forget `-a` (its a common mistake). If you dont want udp2raw to add iptables rule automatically, you can add it manually(take a look at `-g` option) and omit `-a`.
|
||||
`-a` option automatically adds an iptables rule (or a few iptables rules) for you, udp2raw relies on this iptables rule to work stably. Be aware you dont forget `-a` (its a common mistake). If you dont want udp2raw to add iptables rule automatically, you can add it manually(take a look at `-g` option) and omit `-a`.
|
||||
|
||||
|
||||
# Advanced Topic
|
||||
@ -141,11 +143,11 @@ other options:
|
||||
### Iptables rules,`-a` and `-g`
|
||||
This program sends packets via raw socket. In FakeTCP mode, Linux kernel TCP packet processing has to be blocked by a iptables rule on both sides, otherwise the kernel will automatically send RST for an unrecongized TCP packet and you will sustain from stability / peformance problems. You can use `-a` option to let the program automatically add / delete iptables rule on start / exit. You can also use the `-g` option to generate iptables rule and add it manually.
|
||||
|
||||
### `--cipher-mode` and `--auth-mode`
|
||||
### `--cipher-mode` and `--auth-mode`
|
||||
It is suggested to use `aes128cbc` + `hmac_sha1` to obtain maximum security. If you want to run the program on a router, you can try `xor` + `simple`, which can fool packet inspection by firewalls the most of time, but it cannot protect you from serious attacks. Mode none is only for debugging purpose. It is not recommended to set the cipher-mode or auth-mode to none.
|
||||
|
||||
### `--seq-mode`
|
||||
The FakeTCP mode does not behave 100% like a real tcp connection. ISPs may be able to distinguish the simulated tcp traffic from the real TCP traffic (though it's costly). seq-mode can help you change the seq increase behavior slightly. If you experience connection problems, try to change the value.
|
||||
The FakeTCP mode does not behave 100% like a real tcp connection. ISPs may be able to distinguish the simulated tcp traffic from the real TCP traffic (though it's costly). seq-mode can help you change the seq increase behavior slightly. If you experience connection problems, try to change the value.
|
||||
|
||||
### `--lower-level`
|
||||
`--lower-level` allows you to send packet at OSI level 2(link level),so that you can bypass any local iptables rules. If you have a complicated iptables rules which conflicts with udp2raw and you cant(or too lazy to) edit the iptables rules,`--lower-level` can be very useful. Try `--lower-level auto` to auto detect the parameters,you can specify it manually if `auto` fails.
|
||||
@ -192,12 +194,12 @@ At client side,you can use `echo reconnect >fifo.file` to force client to reconn
|
||||
|
||||
# Peformance Test
|
||||
#### Test method:
|
||||
iperf3 TCP via OpenVPN + udp2raw
|
||||
iperf3 TCP via OpenVPN + udp2raw
|
||||
(iperf3 UDP mode is not used because of a bug mentioned in this issue: https://github.com/esnet/iperf/issues/296 . Instead, we package the TCP traffic into UDP by OpenVPN to test the performance. Read [Application](https://github.com/wangyu-/udp2raw-tunnel#application) for details.
|
||||
|
||||
#### iperf3 command:
|
||||
#### iperf3 command:
|
||||
```
|
||||
iperf3 -c 10.222.2.1 -P40
|
||||
iperf3 -c 10.222.2.1 -P40
|
||||
iperf3 -c 10.222.2.1 -P40 -R
|
||||
```
|
||||
#### Environments
|
||||
@ -218,63 +220,6 @@ raw_mode: faketcp cipher_mode: aes128cbc auth_mode: md5
|
||||
|
||||
(reverse speed was simliar and not uploaded)
|
||||
|
||||
# Application
|
||||
## Tunneling any traffic via raw traffic by using udp2raw +openvpn
|
||||
|
||||
1. Bypasses UDP block/UDP QOS
|
||||
|
||||
2. No TCP over TCP problem (TCP over TCP problem http://sites.inka.de/bigred/devel/tcp-tcp.html ,https://community.openvpn.net/openvpn/ticket/2 )
|
||||
|
||||
3. OpenVpn over ICMP also becomes a choice
|
||||
|
||||
4. Supports almost any UDP-based VPN
|
||||
|
||||
More details at [openvpn+udp2raw_guide](https://github.com/wangyu-/udp2raw-tunnel/wiki/udp2raw-openvpn-config-guide)
|
||||
## Speed-up tcp connection via raw traffic by using udp2raw+kcptun
|
||||
kcptun is a tcp connection speed-up program,it speeds-up tcp connection by using kcp protocol on-top of udp.by using udp2raw,you can use kcptun while udp is QoSed or blocked.
|
||||
(kcptun, https://github.com/xtaci/kcptun)
|
||||
|
||||
## Speed-up tcp connection via raw traffic by using udp2raw+finalspeed
|
||||
finalspeed is a tcp connection speed-up program similiar to kcptun,it speeds-up tcp connection by using kcp protocol on-top of udp or tcp.but its tcp mode doesnt support openvz,you can bypass this problem if you use udp2raw+finalspeed together,and icmp mode also becomes avaliable.
|
||||
|
||||
# How to build
|
||||
read [build_guide](/doc/build_guide.md)
|
||||
|
||||
# Other
|
||||
### Easier installation on ArchLinux
|
||||
```
|
||||
yaourt -S udp2raw-tunnel # or
|
||||
pacaur -S udp2raw-tunnel
|
||||
```
|
||||
|
||||
# Related work
|
||||
### kcptun-raw
|
||||
udp2raw was inspired by kcptun-raw,which modified kcptun to support tcp mode.
|
||||
|
||||
https://github.com/Chion82/kcptun-raw
|
||||
### relayRawSocket
|
||||
kcptun-raw was inspired by relayRawSocket. A simple udp to raw tunnel,wrote in python
|
||||
|
||||
https://github.com/linhua55/some_kcptun_tools/tree/master/relayRawSocket
|
||||
### kcpraw
|
||||
another project of kcptun with tcp mode
|
||||
|
||||
https://github.com/ccsexyz/kcpraw
|
||||
|
||||
### icmptunnel
|
||||
Transparently tunnel your IP traffic through ICMP echo and reply packets.
|
||||
|
||||
https://github.com/DhavalKapil/icmptunnel
|
||||
|
||||
### Tcp Minion
|
||||
Tcp Minion is a project which modifid the code of tcp stack in kernel,and implemented real-time out-order udp packet delivery through this modified tcp stack.I failed to find the implementation,but there are some papers avaliable:
|
||||
|
||||
https://arxiv.org/abs/1103.0463
|
||||
|
||||
http://korz.cs.yale.edu/2009/tng/papers/pfldnet10.pdf
|
||||
|
||||
https://pdfs.semanticscholar.org/9e6f/e2306f4385b4eb5416d1fcab16e9361d6ba3.pdf
|
||||
|
||||
# wiki
|
||||
|
||||
Check wiki for more info:
|
||||
|
||||
1433
client.cpp
1433
client.cpp
File diff suppressed because it is too large
Load Diff
1850
common.cpp
1850
common.cpp
File diff suppressed because it is too large
Load Diff
626
common.h
626
common.h
@ -10,16 +10,16 @@
|
||||
#define __STDC_FORMAT_MACROS 1
|
||||
#include <inttypes.h>
|
||||
|
||||
#include<stdio.h>
|
||||
#include<string.h>
|
||||
#include<stdlib.h>
|
||||
#include<getopt.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include <getopt.h>
|
||||
|
||||
#include<unistd.h>
|
||||
#include<errno.h>
|
||||
#include <unistd.h>
|
||||
#include <errno.h>
|
||||
#include <sys/stat.h>
|
||||
#include <stdlib.h> //for exit(0);
|
||||
#include <errno.h> //For errno - the error number
|
||||
#include <stdlib.h> //for exit(0);
|
||||
#include <errno.h> //For errno - the error number
|
||||
#include <fcntl.h>
|
||||
#include <sys/time.h>
|
||||
#include <time.h>
|
||||
@ -27,8 +27,12 @@
|
||||
#include <assert.h>
|
||||
#include <pthread.h>
|
||||
|
||||
#if defined(UDP2RAW_MP)
|
||||
#ifndef USE_LIBNET
|
||||
#define NO_LIBNET
|
||||
#endif
|
||||
|
||||
#if defined(UDP2RAW_MP)
|
||||
const int is_udp2raw_mp = 1;
|
||||
#if !defined(__CYGWIN__) && !defined(__MINGW32__)
|
||||
#include <pcap.h>
|
||||
#else
|
||||
@ -41,7 +45,8 @@
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define UDP2RAW_LINUX
|
||||
const int is_udp2raw_mp = 0;
|
||||
//#include <linux/if_ether.h>
|
||||
#include <linux/filter.h>
|
||||
#include <linux/if_packet.h>
|
||||
@ -53,7 +58,11 @@
|
||||
|
||||
#endif
|
||||
|
||||
#if !defined(NO_LIBEV_EMBED)
|
||||
#include <my_ev.h>
|
||||
#else
|
||||
#include "ev.h"
|
||||
#endif
|
||||
|
||||
#if defined(__MINGW32__)
|
||||
#include <winsock2.h>
|
||||
@ -70,51 +79,47 @@ typedef int socklen_t;
|
||||
#include <netinet/in.h>
|
||||
#endif
|
||||
|
||||
|
||||
#include<unordered_map>
|
||||
#include <unordered_map>
|
||||
#include <fstream>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
#include <map>
|
||||
#include <set>
|
||||
#include <list>
|
||||
using namespace std;
|
||||
using namespace std;
|
||||
|
||||
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN || \
|
||||
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __BIG_ENDIAN || \
|
||||
defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__ || \
|
||||
defined(__BIG_ENDIAN__) || \
|
||||
defined(__ARMEB__) || \
|
||||
defined(__THUMBEB__) || \
|
||||
defined(__AARCH64EB__) || \
|
||||
defined(__BIG_ENDIAN__) || \
|
||||
defined(__ARMEB__) || \
|
||||
defined(__THUMBEB__) || \
|
||||
defined(__AARCH64EB__) || \
|
||||
defined(_MIBSEB) || defined(__MIBSEB) || defined(__MIBSEB__)
|
||||
#define UDP2RAW_BIG_ENDIAN 1
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN || \
|
||||
#if defined(__BYTE_ORDER) && __BYTE_ORDER == __LITTLE_ENDIAN || \
|
||||
defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ || \
|
||||
defined(__LITTLE_ENDIAN__) || \
|
||||
defined(__ARMEL__) || \
|
||||
defined(__THUMBEL__) || \
|
||||
defined(__AARCH64EL__) || \
|
||||
defined(__LITTLE_ENDIAN__) || \
|
||||
defined(__ARMEL__) || \
|
||||
defined(__THUMBEL__) || \
|
||||
defined(__AARCH64EL__) || \
|
||||
defined(_MIPSEL) || defined(__MIPSEL) || defined(__MIPSEL__)
|
||||
#define UDP2RAW_LITTLE_ENDIAN 1
|
||||
#endif
|
||||
|
||||
#if defined(UDP2RAW_BIG_ENDIAN) &&defined(UDP2RAW_LITTLE_ENDIAN)
|
||||
#if defined(UDP2RAW_BIG_ENDIAN) && defined(UDP2RAW_LITTLE_ENDIAN)
|
||||
#error "endian detection conflicts"
|
||||
#endif
|
||||
|
||||
|
||||
#if !defined(UDP2RAW_BIG_ENDIAN) && !defined(UDP2RAW_LITTLE_ENDIAN)
|
||||
#error "endian detection failed"
|
||||
#endif
|
||||
|
||||
|
||||
#if defined(__MINGW32__)
|
||||
int inet_pton(int af, const char *src, void *dst);
|
||||
const char *inet_ntop(int af, const void *src, char *dst, socklen_t size);
|
||||
#define setsockopt(a,b,c,d,e) setsockopt(a,b,c,(const char *)(d),e)
|
||||
#define setsockopt(a, b, c, d, e) setsockopt(a, b, c, (const char *)(d), e)
|
||||
#endif
|
||||
|
||||
char *get_sock_error();
|
||||
@ -122,21 +127,18 @@ int get_sock_errno();
|
||||
|
||||
#if defined(__MINGW32__)
|
||||
typedef SOCKET my_fd_t;
|
||||
inline int sock_close(my_fd_t fd)
|
||||
{
|
||||
return closesocket(fd);
|
||||
inline int sock_close(my_fd_t fd) {
|
||||
return closesocket(fd);
|
||||
}
|
||||
#else
|
||||
typedef int my_fd_t;
|
||||
inline int sock_close(my_fd_t fd)
|
||||
{
|
||||
return close(fd);
|
||||
inline int sock_close(my_fd_t fd) {
|
||||
return close(fd);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
typedef unsigned long long u64_t; //this works on most platform,avoid using the PRId64
|
||||
typedef unsigned long long u64_t; // this works on most platform,avoid using the PRId64
|
||||
typedef long long i64_t;
|
||||
|
||||
typedef unsigned int u32_t;
|
||||
@ -155,210 +157,233 @@ typedef u64_t anti_replay_seq_t;
|
||||
|
||||
typedef u64_t my_time_t;
|
||||
|
||||
const int max_addr_len=100;
|
||||
const int max_addr_len = 100;
|
||||
|
||||
extern int force_socket_buf;
|
||||
|
||||
extern int g_fix_gro;
|
||||
|
||||
/*
|
||||
struct ip_port_t
|
||||
{
|
||||
u32_t ip;
|
||||
int port;
|
||||
void from_u64(u64_t u64);
|
||||
u64_t to_u64();
|
||||
char * to_s();
|
||||
u32_t ip;
|
||||
int port;
|
||||
void from_u64(u64_t u64);
|
||||
u64_t to_u64();
|
||||
char * to_s();
|
||||
};*/
|
||||
|
||||
typedef u64_t fd64_t;
|
||||
|
||||
u32_t djb2(unsigned char *str,int len);
|
||||
u32_t sdbm(unsigned char *str,int len);
|
||||
u32_t djb2(unsigned char *str, int len);
|
||||
u32_t sdbm(unsigned char *str, int len);
|
||||
|
||||
struct address_t //TODO scope id
|
||||
struct address_t // TODO scope id
|
||||
{
|
||||
struct hash_function
|
||||
{
|
||||
u32_t operator()(const address_t &key) const
|
||||
{
|
||||
return sdbm((unsigned char*)&key.inner,sizeof(key.inner));
|
||||
}
|
||||
};
|
||||
struct hash_function {
|
||||
u32_t operator()(const address_t &key) const {
|
||||
return sdbm((unsigned char *)&key.inner, sizeof(key.inner));
|
||||
}
|
||||
};
|
||||
|
||||
union storage_t //sockaddr_storage is too huge, we dont use it.
|
||||
{
|
||||
sockaddr_in ipv4;
|
||||
sockaddr_in6 ipv6;
|
||||
};
|
||||
storage_t inner;
|
||||
|
||||
address_t()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
void clear()
|
||||
{
|
||||
memset(&inner,0,sizeof(inner));
|
||||
}
|
||||
int from_ip_port(u32_t ip, int port)
|
||||
{
|
||||
clear();
|
||||
inner.ipv4.sin_family=AF_INET;
|
||||
inner.ipv4.sin_port=htons(port);
|
||||
inner.ipv4.sin_addr.s_addr=ip;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int from_ip_port_new(int type, void * ip, int port)
|
||||
{
|
||||
clear();
|
||||
if(type==AF_INET)
|
||||
{
|
||||
inner.ipv4.sin_family=AF_INET;
|
||||
inner.ipv4.sin_port=htons(port);
|
||||
inner.ipv4.sin_addr.s_addr=*((u32_t *)ip);
|
||||
}
|
||||
else if(type==AF_INET6)
|
||||
{
|
||||
inner.ipv6.sin6_family=AF_INET6;
|
||||
inner.ipv6.sin6_port=htons(port);
|
||||
inner.ipv6.sin6_addr=*((in6_addr*)ip);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int from_str(char * str);
|
||||
|
||||
int from_str_ip_only(char * str);
|
||||
|
||||
int from_sockaddr(sockaddr *,socklen_t);
|
||||
|
||||
char* get_str();
|
||||
void to_str(char *);
|
||||
|
||||
inline u32_t get_type()
|
||||
{
|
||||
u32_t ret=((sockaddr*)&inner)->sa_family;
|
||||
assert(ret==AF_INET||ret==AF_INET6);
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline u32_t get_len()
|
||||
{
|
||||
u32_t type=get_type();
|
||||
switch(type)
|
||||
{
|
||||
case AF_INET:
|
||||
return sizeof(sockaddr_in);
|
||||
case AF_INET6:
|
||||
return sizeof(sockaddr_in6);
|
||||
default:
|
||||
assert(0==1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
inline u32_t get_port()
|
||||
{
|
||||
u32_t type=get_type();
|
||||
switch(type)
|
||||
{
|
||||
case AF_INET:
|
||||
return ntohs(inner.ipv4.sin_port);
|
||||
case AF_INET6:
|
||||
return ntohs(inner.ipv6.sin6_port);
|
||||
default:
|
||||
assert(0==1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
inline void set_port(int port)
|
||||
{
|
||||
u32_t type=get_type();
|
||||
switch(type)
|
||||
{
|
||||
case AF_INET:
|
||||
inner.ipv4.sin_port=htons(port);
|
||||
break;
|
||||
case AF_INET6:
|
||||
inner.ipv6.sin6_port=htons(port);
|
||||
break;
|
||||
default:
|
||||
assert(0==1);
|
||||
}
|
||||
return ;
|
||||
}
|
||||
|
||||
bool operator == (const address_t &b) const
|
||||
union storage_t // sockaddr_storage is too huge, we dont use it.
|
||||
{
|
||||
//return this->data==b.data;
|
||||
return memcmp(&this->inner,&b.inner,sizeof(this->inner))==0;
|
||||
sockaddr_in ipv4;
|
||||
sockaddr_in6 ipv6;
|
||||
};
|
||||
storage_t inner;
|
||||
|
||||
address_t() {
|
||||
clear();
|
||||
}
|
||||
void clear() {
|
||||
memset(&inner, 0, sizeof(inner));
|
||||
}
|
||||
int from_ip_port(u32_t ip, int port) {
|
||||
clear();
|
||||
inner.ipv4.sin_family = AF_INET;
|
||||
inner.ipv4.sin_port = htons(port);
|
||||
inner.ipv4.sin_addr.s_addr = ip;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int from_ip_port_new(int type, void *ip, int port) {
|
||||
clear();
|
||||
if (type == AF_INET) {
|
||||
inner.ipv4.sin_family = AF_INET;
|
||||
inner.ipv4.sin_port = htons(port);
|
||||
inner.ipv4.sin_addr.s_addr = *((u32_t *)ip);
|
||||
} else if (type == AF_INET6) {
|
||||
inner.ipv6.sin6_family = AF_INET6;
|
||||
inner.ipv6.sin6_port = htons(port);
|
||||
inner.ipv6.sin6_addr = *((in6_addr *)ip);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int from_str(char *str);
|
||||
|
||||
int from_str_ip_only(char *str);
|
||||
|
||||
int from_sockaddr(sockaddr *, socklen_t);
|
||||
|
||||
char *get_str();
|
||||
void to_str(char *);
|
||||
|
||||
inline u32_t get_type() {
|
||||
u32_t ret = ((sockaddr *)&inner)->sa_family;
|
||||
assert(ret == AF_INET || ret == AF_INET6);
|
||||
return ret;
|
||||
}
|
||||
|
||||
inline u32_t get_len() {
|
||||
u32_t type = get_type();
|
||||
switch (type) {
|
||||
case AF_INET:
|
||||
return sizeof(sockaddr_in);
|
||||
case AF_INET6:
|
||||
return sizeof(sockaddr_in6);
|
||||
default:
|
||||
assert(0 == 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
inline u32_t get_port() {
|
||||
u32_t type = get_type();
|
||||
switch (type) {
|
||||
case AF_INET:
|
||||
return ntohs(inner.ipv4.sin_port);
|
||||
case AF_INET6:
|
||||
return ntohs(inner.ipv6.sin6_port);
|
||||
default:
|
||||
assert(0 == 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
inline void set_port(int port) {
|
||||
u32_t type = get_type();
|
||||
switch (type) {
|
||||
case AF_INET:
|
||||
inner.ipv4.sin_port = htons(port);
|
||||
break;
|
||||
case AF_INET6:
|
||||
inner.ipv6.sin6_port = htons(port);
|
||||
break;
|
||||
default:
|
||||
assert(0 == 1);
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
bool operator==(const address_t &b) const {
|
||||
// return this->data==b.data;
|
||||
return memcmp(&this->inner, &b.inner, sizeof(this->inner)) == 0;
|
||||
}
|
||||
|
||||
int new_connected_udp_fd();
|
||||
|
||||
char* get_ip();
|
||||
char *get_ip();
|
||||
};
|
||||
|
||||
namespace std {
|
||||
template <>
|
||||
struct hash<address_t>
|
||||
{
|
||||
std::size_t operator()(const address_t& key) const
|
||||
{
|
||||
struct hash<address_t> {
|
||||
std::size_t operator()(const address_t &key) const {
|
||||
// return address_t::hash_function(k);
|
||||
return sdbm((unsigned char *)&key.inner, sizeof(key.inner));
|
||||
}
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
//return address_t::hash_function(k);
|
||||
return sdbm((unsigned char*)&key.inner,sizeof(key.inner));
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
union my_ip_t //just a simple version of address_t,stores ip only
|
||||
union my_ip_t // just a simple version of address_t,stores ip only
|
||||
{
|
||||
u32_t v4;
|
||||
in6_addr v6;
|
||||
u32_t v4;
|
||||
in6_addr v6;
|
||||
|
||||
bool equal (const my_ip_t &b) const;
|
||||
bool equal(const my_ip_t &b) const;
|
||||
|
||||
//int from_str(char * str);
|
||||
char * get_str1() const;
|
||||
char * get_str2() const;
|
||||
// int from_str(char * str);
|
||||
char *get_str1() const;
|
||||
char *get_str2() const;
|
||||
|
||||
int from_address_t(address_t a);
|
||||
|
||||
};
|
||||
|
||||
struct not_copy_able_t
|
||||
{
|
||||
not_copy_able_t()
|
||||
{
|
||||
|
||||
}
|
||||
not_copy_able_t(const not_copy_able_t &other)
|
||||
{
|
||||
assert(0==1);
|
||||
}
|
||||
const not_copy_able_t & operator=(const not_copy_able_t &other)
|
||||
{
|
||||
assert(0==1);
|
||||
return other;
|
||||
}
|
||||
struct not_copy_able_t {
|
||||
not_copy_able_t() {
|
||||
}
|
||||
not_copy_able_t(const not_copy_able_t &other) {
|
||||
assert(0 == 1);
|
||||
}
|
||||
const not_copy_able_t &operator=(const not_copy_able_t &other) {
|
||||
assert(0 == 1);
|
||||
return other;
|
||||
}
|
||||
};
|
||||
|
||||
const int huge_data_len = 65535 + 100; // a packet with link level header might be larger than 65535
|
||||
const int huge_buf_len = huge_data_len + 100;
|
||||
|
||||
const int max_data_len=1800;
|
||||
const int buf_len=max_data_len+400;
|
||||
const int max_data_len = 1800;
|
||||
const int buf_len = max_data_len + 400;
|
||||
|
||||
//const int max_address_len=512;
|
||||
// const int max_address_len=512;
|
||||
|
||||
#ifdef UDP2RAW_MP
|
||||
const int queue_len = 200;
|
||||
|
||||
struct queue_t {
|
||||
char data[queue_len][huge_buf_len];
|
||||
int data_len[queue_len];
|
||||
|
||||
int head = 0;
|
||||
int tail = 0;
|
||||
void clear() {
|
||||
head = tail = 0;
|
||||
}
|
||||
int empty() {
|
||||
if (head == tail)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
int full() {
|
||||
if ((tail + 1) % queue_len == head)
|
||||
return 1;
|
||||
else
|
||||
return 0;
|
||||
}
|
||||
void peek_front(char *&p, int &len) {
|
||||
assert(!empty());
|
||||
p = data[head];
|
||||
len = data_len[head];
|
||||
}
|
||||
void pop_front() {
|
||||
assert(!empty());
|
||||
head++;
|
||||
head %= queue_len;
|
||||
}
|
||||
void push_back(char *p, int len) {
|
||||
assert(!full());
|
||||
memcpy(data[tail], p, len);
|
||||
data_len[tail] = len;
|
||||
tail++;
|
||||
tail %= queue_len;
|
||||
}
|
||||
};
|
||||
|
||||
int init_ws();
|
||||
#endif
|
||||
u64_t get_current_time();
|
||||
u64_t pack_u64(u32_t a,u32_t b);
|
||||
u64_t pack_u64(u32_t a, u32_t b);
|
||||
|
||||
u32_t get_u64_h(u64_t a);
|
||||
|
||||
u32_t get_u64_l(u64_t a);
|
||||
|
||||
char * my_ntoa(u32_t ip);
|
||||
char *my_ntoa(u32_t ip);
|
||||
|
||||
void init_random_number_fd();
|
||||
u64_t get_true_random_number_64();
|
||||
@ -367,138 +392,131 @@ u32_t get_true_random_number_nz();
|
||||
u64_t ntoh64(u64_t a);
|
||||
u64_t hton64(u64_t a);
|
||||
|
||||
void write_u16(char *,u16_t a);// network order
|
||||
void write_u16(char *, u16_t a); // network order
|
||||
u16_t read_u16(char *);
|
||||
void write_u32(char *,u32_t a);// network order
|
||||
void write_u32(char *, u32_t a); // network order
|
||||
u32_t read_u32(char *);
|
||||
void write_u64(char *,u64_t a);
|
||||
void write_u64(char *, u64_t a);
|
||||
u64_t read_u64(char *);
|
||||
|
||||
bool larger_than_u16(uint16_t a,uint16_t b);
|
||||
bool larger_than_u32(u32_t a,u32_t b);
|
||||
bool larger_than_u16(uint16_t a, uint16_t b);
|
||||
bool larger_than_u32(u32_t a, u32_t b);
|
||||
void setnonblocking(int sock);
|
||||
int set_buf_size(int fd,int socket_buf_size);
|
||||
int set_buf_size(int fd, int socket_buf_size);
|
||||
|
||||
void myexit(int a);
|
||||
|
||||
unsigned short csum(const unsigned short *ptr,int nbytes);
|
||||
unsigned short csum_with_header(char* header,int hlen,const unsigned short *ptr,int nbytes);
|
||||
unsigned short csum(const unsigned short *ptr, int nbytes);
|
||||
unsigned short csum_with_header(char *header, int hlen, const unsigned short *ptr, int nbytes);
|
||||
|
||||
int numbers_to_char(my_id_t id1,my_id_t id2,my_id_t id3,char * &data,int &len);
|
||||
int char_to_numbers(const char * data,int len,my_id_t &id1,my_id_t &id2,my_id_t &id3);
|
||||
int numbers_to_char(my_id_t id1, my_id_t id2, my_id_t id3, char *&data, int &len);
|
||||
int char_to_numbers(const char *data, int len, my_id_t &id1, my_id_t &id2, my_id_t &id3);
|
||||
|
||||
const int show_none=0;
|
||||
const int show_command=0x1;
|
||||
const int show_log=0x2;
|
||||
const int show_all=show_command|show_log;
|
||||
const int show_none = 0;
|
||||
const int show_command = 0x1;
|
||||
const int show_log = 0x2;
|
||||
const int show_all = show_command | show_log;
|
||||
|
||||
int run_command(string command,char * &output,int flag=show_all);
|
||||
//int run_command_no_log(string command,char * &output);
|
||||
int read_file(const char * file,string &output);
|
||||
int run_command(string command, char *&output, int flag = show_all);
|
||||
// int run_command_no_log(string command,char * &output);
|
||||
int read_file(const char *file, string &output);
|
||||
|
||||
vector<string> string_to_vec(const char * s,const char * sp);
|
||||
vector< vector <string> > string_to_vec2(const char * s);
|
||||
vector<string> string_to_vec(const char *s, const char *sp);
|
||||
vector<vector<string> > string_to_vec2(const char *s);
|
||||
|
||||
string trim(const string& str, char c);
|
||||
string trim(const string &str, char c);
|
||||
|
||||
string trim_conf_line(const string& str);
|
||||
string trim_conf_line(const string &str);
|
||||
|
||||
vector<string> parse_conf_line(const string& s);
|
||||
vector<string> parse_conf_line(const string &s);
|
||||
|
||||
int hex_to_u32_with_endian(const string & a,u32_t &output);
|
||||
int hex_to_u32(const string & a,u32_t &output);
|
||||
//extern string iptables_pattern;
|
||||
int hex_to_u32_with_endian(const string &a, u32_t &output);
|
||||
int hex_to_u32(const string &a, u32_t &output);
|
||||
// extern string iptables_pattern;
|
||||
|
||||
int create_fifo(char * file);
|
||||
int create_fifo(char *file);
|
||||
|
||||
void print_binary_chars(const char * a,int len);
|
||||
void print_binary_chars(const char *a, int len);
|
||||
|
||||
template <class key_t>
|
||||
struct lru_collector_t:not_copy_able_t
|
||||
{
|
||||
//typedef void* key_t;
|
||||
//#define key_t void*
|
||||
struct lru_pair_t
|
||||
{
|
||||
key_t key;
|
||||
my_time_t ts;
|
||||
};
|
||||
struct lru_collector_t : not_copy_able_t {
|
||||
// typedef void* key_t;
|
||||
//#define key_t void*
|
||||
struct lru_pair_t {
|
||||
key_t key;
|
||||
my_time_t ts;
|
||||
};
|
||||
|
||||
unordered_map<key_t,typename list<lru_pair_t>::iterator> mp;
|
||||
unordered_map<key_t, typename list<lru_pair_t>::iterator> mp;
|
||||
|
||||
list<lru_pair_t> q;
|
||||
int update(key_t key)
|
||||
{
|
||||
assert(mp.find(key)!=mp.end());
|
||||
auto it=mp[key];
|
||||
q.erase(it);
|
||||
list<lru_pair_t> q;
|
||||
int update(key_t key) {
|
||||
assert(mp.find(key) != mp.end());
|
||||
auto it = mp[key];
|
||||
q.erase(it);
|
||||
|
||||
my_time_t value=get_current_time();
|
||||
if(!q.empty())
|
||||
{
|
||||
assert(value >=q.front().ts);
|
||||
}
|
||||
lru_pair_t tmp; tmp.key=key; tmp.ts=value;
|
||||
q.push_front( tmp);
|
||||
mp[key]=q.begin();
|
||||
my_time_t value = get_current_time();
|
||||
if (!q.empty()) {
|
||||
assert(value >= q.front().ts);
|
||||
}
|
||||
lru_pair_t tmp;
|
||||
tmp.key = key;
|
||||
tmp.ts = value;
|
||||
q.push_front(tmp);
|
||||
mp[key] = q.begin();
|
||||
|
||||
return 0;
|
||||
}
|
||||
int new_key(key_t key)
|
||||
{
|
||||
assert(mp.find(key)==mp.end());
|
||||
return 0;
|
||||
}
|
||||
int new_key(key_t key) {
|
||||
assert(mp.find(key) == mp.end());
|
||||
|
||||
my_time_t value=get_current_time();
|
||||
if(!q.empty())
|
||||
{
|
||||
assert(value >=q.front().ts);
|
||||
}
|
||||
lru_pair_t tmp; tmp.key=key; tmp.ts=value;
|
||||
q.push_front( tmp);
|
||||
mp[key]=q.begin();
|
||||
my_time_t value = get_current_time();
|
||||
if (!q.empty()) {
|
||||
assert(value >= q.front().ts);
|
||||
}
|
||||
lru_pair_t tmp;
|
||||
tmp.key = key;
|
||||
tmp.ts = value;
|
||||
q.push_front(tmp);
|
||||
mp[key] = q.begin();
|
||||
|
||||
return 0;
|
||||
}
|
||||
int size()
|
||||
{
|
||||
return q.size();
|
||||
}
|
||||
int empty()
|
||||
{
|
||||
return q.empty();
|
||||
}
|
||||
void clear()
|
||||
{
|
||||
mp.clear(); q.clear();
|
||||
}
|
||||
my_time_t ts_of(key_t key)
|
||||
{
|
||||
assert(mp.find(key)!=mp.end());
|
||||
return mp[key]->ts;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int size() {
|
||||
return q.size();
|
||||
}
|
||||
int empty() {
|
||||
return q.empty();
|
||||
}
|
||||
void clear() {
|
||||
mp.clear();
|
||||
q.clear();
|
||||
}
|
||||
my_time_t ts_of(key_t key) {
|
||||
assert(mp.find(key) != mp.end());
|
||||
return mp[key]->ts;
|
||||
}
|
||||
|
||||
my_time_t peek_back(key_t &key)
|
||||
{
|
||||
assert(!q.empty());
|
||||
auto it=q.end(); it--;
|
||||
key=it->key;
|
||||
return it->ts;
|
||||
}
|
||||
void erase(key_t key)
|
||||
{
|
||||
assert(mp.find(key)!=mp.end());
|
||||
q.erase(mp[key]);
|
||||
mp.erase(key);
|
||||
}
|
||||
/*
|
||||
void erase_back()
|
||||
{
|
||||
assert(!q.empty());
|
||||
auto it=q.end(); it--;
|
||||
key_t key=it->key;
|
||||
erase(key);
|
||||
}*/
|
||||
my_time_t peek_back(key_t &key) {
|
||||
assert(!q.empty());
|
||||
auto it = q.end();
|
||||
it--;
|
||||
key = it->key;
|
||||
return it->ts;
|
||||
}
|
||||
void erase(key_t key) {
|
||||
assert(mp.find(key) != mp.end());
|
||||
q.erase(mp[key]);
|
||||
mp.erase(key);
|
||||
}
|
||||
/*
|
||||
void erase_back()
|
||||
{
|
||||
assert(!q.empty());
|
||||
auto it=q.end(); it--;
|
||||
key_t key=it->key;
|
||||
erase(key);
|
||||
}*/
|
||||
};
|
||||
|
||||
|
||||
#endif /* COMMON_H_ */
|
||||
|
||||
1146
connection.cpp
1146
connection.cpp
File diff suppressed because it is too large
Load Diff
513
connection.h
513
connection.h
@ -16,335 +16,298 @@ extern int disable_anti_replay;
|
||||
#include "network.h"
|
||||
#include "misc.h"
|
||||
|
||||
const int disable_conv_clear=0;//a udp connection in the multiplexer is called conversation in this program,conv for short.
|
||||
const int disable_conv_clear = 0; // a udp connection in the multiplexer is called conversation in this program,conv for short.
|
||||
|
||||
|
||||
|
||||
struct anti_replay_t //its for anti replay attack,similar to openvpn/ipsec 's anti replay window
|
||||
struct anti_replay_t // its for anti replay attack,similar to openvpn/ipsec 's anti replay window
|
||||
{
|
||||
u64_t max_packet_received;
|
||||
char window[anti_replay_window_size];
|
||||
anti_replay_seq_t anti_replay_seq;
|
||||
anti_replay_seq_t get_new_seq_for_send();
|
||||
anti_replay_t();
|
||||
void re_init();
|
||||
u64_t max_packet_received;
|
||||
char window[anti_replay_window_size];
|
||||
anti_replay_seq_t anti_replay_seq;
|
||||
anti_replay_seq_t get_new_seq_for_send();
|
||||
anti_replay_t();
|
||||
void re_init();
|
||||
|
||||
int is_vaild(u64_t seq);
|
||||
};//anti_replay;
|
||||
int is_vaild(u64_t seq);
|
||||
}; // anti_replay;
|
||||
|
||||
void server_clear_function(u64_t u64);
|
||||
|
||||
#include <type_traits>
|
||||
|
||||
template <class T>
|
||||
template <class T>
|
||||
struct conv_manager_t // manage the udp connections
|
||||
{
|
||||
//typedef hash_map map;
|
||||
unordered_map<T,u32_t> data_to_conv; //conv and u64 are both supposed to be uniq
|
||||
unordered_map<u32_t,T> conv_to_data;
|
||||
// typedef hash_map map;
|
||||
unordered_map<T, u32_t> data_to_conv; // conv and u64 are both supposed to be uniq
|
||||
unordered_map<u32_t, T> conv_to_data;
|
||||
|
||||
lru_collector_t<u32_t> lru;
|
||||
//unordered_map<u32_t,u64_t> conv_last_active_time;
|
||||
lru_collector_t<u32_t> lru;
|
||||
// unordered_map<u32_t,u64_t> conv_last_active_time;
|
||||
|
||||
//unordered_map<u32_t,u64_t>::iterator clear_it;
|
||||
// unordered_map<u32_t,u64_t>::iterator clear_it;
|
||||
|
||||
void (*additional_clear_function)(T data) =0;
|
||||
void (*additional_clear_function)(T data) = 0;
|
||||
|
||||
long long last_clear_time;
|
||||
long long last_clear_time;
|
||||
|
||||
conv_manager_t()
|
||||
{
|
||||
//clear_it=conv_last_active_time.begin();
|
||||
long long last_clear_time=0;
|
||||
additional_clear_function=0;
|
||||
}
|
||||
~conv_manager_t()
|
||||
{
|
||||
clear();
|
||||
}
|
||||
int get_size()
|
||||
{
|
||||
return conv_to_data.size();
|
||||
}
|
||||
void reserve()
|
||||
{
|
||||
data_to_conv.reserve(10007);
|
||||
conv_to_data.reserve(10007);
|
||||
//conv_last_active_time.reserve(10007);
|
||||
conv_manager_t() {
|
||||
// clear_it=conv_last_active_time.begin();
|
||||
long long last_clear_time = 0;
|
||||
additional_clear_function = 0;
|
||||
}
|
||||
~conv_manager_t() {
|
||||
clear();
|
||||
}
|
||||
int get_size() {
|
||||
return conv_to_data.size();
|
||||
}
|
||||
void reserve() {
|
||||
data_to_conv.reserve(10007);
|
||||
conv_to_data.reserve(10007);
|
||||
// conv_last_active_time.reserve(10007);
|
||||
|
||||
lru.mp.reserve(10007);
|
||||
}
|
||||
void clear()
|
||||
{
|
||||
if(disable_conv_clear) return ;
|
||||
lru.mp.reserve(10007);
|
||||
}
|
||||
void clear() {
|
||||
if (disable_conv_clear) return;
|
||||
|
||||
if(additional_clear_function!=0)
|
||||
{
|
||||
for(auto it=conv_to_data.begin();it!=conv_to_data.end();it++)
|
||||
{
|
||||
//int fd=int((it->second<<32u)>>32u);
|
||||
additional_clear_function( it->second);
|
||||
}
|
||||
}
|
||||
data_to_conv.clear();
|
||||
conv_to_data.clear();
|
||||
if (additional_clear_function != 0) {
|
||||
for (auto it = conv_to_data.begin(); it != conv_to_data.end(); it++) {
|
||||
// int fd=int((it->second<<32u)>>32u);
|
||||
additional_clear_function(it->second);
|
||||
}
|
||||
}
|
||||
data_to_conv.clear();
|
||||
conv_to_data.clear();
|
||||
|
||||
lru.clear();
|
||||
//conv_last_active_time.clear();
|
||||
lru.clear();
|
||||
// conv_last_active_time.clear();
|
||||
|
||||
//clear_it=conv_last_active_time.begin();
|
||||
// clear_it=conv_last_active_time.begin();
|
||||
}
|
||||
u32_t get_new_conv() {
|
||||
u32_t conv = get_true_random_number_nz();
|
||||
while (conv_to_data.find(conv) != conv_to_data.end()) {
|
||||
conv = get_true_random_number_nz();
|
||||
}
|
||||
return conv;
|
||||
}
|
||||
int is_conv_used(u32_t conv) {
|
||||
return conv_to_data.find(conv) != conv_to_data.end();
|
||||
}
|
||||
int is_data_used(T data) {
|
||||
return data_to_conv.find(data) != data_to_conv.end();
|
||||
}
|
||||
u32_t find_conv_by_data(T data) {
|
||||
return data_to_conv[data];
|
||||
}
|
||||
T find_data_by_conv(u32_t conv) {
|
||||
return conv_to_data[conv];
|
||||
}
|
||||
int update_active_time(u32_t conv) {
|
||||
// return conv_last_active_time[conv]=get_current_time();
|
||||
lru.update(conv);
|
||||
return 0;
|
||||
}
|
||||
int insert_conv(u32_t conv, T data) {
|
||||
data_to_conv[data] = conv;
|
||||
conv_to_data[conv] = data;
|
||||
// conv_last_active_time[conv]=get_current_time();
|
||||
lru.new_key(conv);
|
||||
return 0;
|
||||
}
|
||||
int erase_conv(u32_t conv) {
|
||||
if (disable_conv_clear) return 0;
|
||||
T data = conv_to_data[conv];
|
||||
if (additional_clear_function != 0) {
|
||||
additional_clear_function(data);
|
||||
}
|
||||
conv_to_data.erase(conv);
|
||||
data_to_conv.erase(data);
|
||||
// conv_last_active_time.erase(conv);
|
||||
lru.erase(conv);
|
||||
return 0;
|
||||
}
|
||||
int clear_inactive(char *info = 0) {
|
||||
if (get_current_time() - last_clear_time > conv_clear_interval) {
|
||||
last_clear_time = get_current_time();
|
||||
return clear_inactive0(info);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int clear_inactive0(char *info) {
|
||||
if (disable_conv_clear) return 0;
|
||||
|
||||
}
|
||||
u32_t get_new_conv()
|
||||
{
|
||||
u32_t conv=get_true_random_number_nz();
|
||||
while(conv_to_data.find(conv)!=conv_to_data.end())
|
||||
{
|
||||
conv=get_true_random_number_nz();
|
||||
}
|
||||
return conv;
|
||||
}
|
||||
int is_conv_used(u32_t conv)
|
||||
{
|
||||
return conv_to_data.find(conv)!=conv_to_data.end();
|
||||
}
|
||||
int is_data_used(T data)
|
||||
{
|
||||
return data_to_conv.find(data)!=data_to_conv.end();
|
||||
}
|
||||
u32_t find_conv_by_data(T data)
|
||||
{
|
||||
return data_to_conv[data];
|
||||
}
|
||||
T find_data_by_conv(u32_t conv)
|
||||
{
|
||||
return conv_to_data[conv];
|
||||
}
|
||||
int update_active_time(u32_t conv)
|
||||
{
|
||||
//return conv_last_active_time[conv]=get_current_time();
|
||||
lru.update(conv);
|
||||
return 0;
|
||||
}
|
||||
int insert_conv(u32_t conv,T data)
|
||||
{
|
||||
data_to_conv[data]=conv;
|
||||
conv_to_data[conv]=data;
|
||||
//conv_last_active_time[conv]=get_current_time();
|
||||
lru.new_key(conv);
|
||||
return 0;
|
||||
}
|
||||
int erase_conv(u32_t conv)
|
||||
{
|
||||
if(disable_conv_clear) return 0;
|
||||
T data=conv_to_data[conv];
|
||||
if(additional_clear_function!=0)
|
||||
{
|
||||
additional_clear_function(data);
|
||||
}
|
||||
conv_to_data.erase(conv);
|
||||
data_to_conv.erase(data);
|
||||
//conv_last_active_time.erase(conv);
|
||||
lru.erase(conv);
|
||||
return 0;
|
||||
}
|
||||
int clear_inactive(char * info=0)
|
||||
{
|
||||
if(get_current_time()-last_clear_time>conv_clear_interval)
|
||||
{
|
||||
last_clear_time=get_current_time();
|
||||
return clear_inactive0(info);
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int clear_inactive0(char * info)
|
||||
{
|
||||
if(disable_conv_clear) return 0;
|
||||
unordered_map<u32_t, u64_t>::iterator it;
|
||||
unordered_map<u32_t, u64_t>::iterator old_it;
|
||||
|
||||
// map<uint32_t,uint64_t>::iterator it;
|
||||
int cnt = 0;
|
||||
// it=clear_it;
|
||||
int size = lru.size();
|
||||
int num_to_clean = size / conv_clear_ratio + conv_clear_min; // clear 1/10 each time,to avoid latency glitch
|
||||
|
||||
unordered_map<u32_t,u64_t>::iterator it;
|
||||
unordered_map<u32_t,u64_t>::iterator old_it;
|
||||
num_to_clean = min(num_to_clean, size);
|
||||
|
||||
//map<uint32_t,uint64_t>::iterator it;
|
||||
int cnt=0;
|
||||
//it=clear_it;
|
||||
int size=lru.size();
|
||||
int num_to_clean=size/conv_clear_ratio+conv_clear_min; //clear 1/10 each time,to avoid latency glitch
|
||||
my_time_t current_time = get_current_time();
|
||||
for (;;) {
|
||||
if (cnt >= num_to_clean) break;
|
||||
if (lru.empty()) break;
|
||||
|
||||
num_to_clean=min(num_to_clean,size);
|
||||
u32_t conv;
|
||||
my_time_t ts = lru.peek_back(conv);
|
||||
|
||||
my_time_t current_time=get_current_time();
|
||||
for(;;)
|
||||
{
|
||||
if(cnt>=num_to_clean) break;
|
||||
if(lru.empty()) break;
|
||||
if (current_time - ts < conv_timeout) break;
|
||||
|
||||
u32_t conv;
|
||||
my_time_t ts=lru.peek_back(conv);
|
||||
erase_conv(conv);
|
||||
if (info == 0) {
|
||||
mylog(log_info, "conv %x cleared\n", conv);
|
||||
} else {
|
||||
mylog(log_info, "[%s]conv %x cleared\n", info, conv);
|
||||
}
|
||||
cnt++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
if(current_time- ts < conv_timeout) break;
|
||||
/*
|
||||
conv_manager_t();
|
||||
~conv_manager_t();
|
||||
int get_size();
|
||||
void reserve();
|
||||
void clear();
|
||||
u32_t get_new_conv();
|
||||
int is_conv_used(u32_t conv);
|
||||
int is_u64_used(T u64);
|
||||
u32_t find_conv_by_u64(T u64);
|
||||
T find_u64_by_conv(u32_t conv);
|
||||
int update_active_time(u32_t conv);
|
||||
int insert_conv(u32_t conv,T u64);
|
||||
int erase_conv(u32_t conv);
|
||||
int clear_inactive(char * ip_port=0);
|
||||
int clear_inactive0(char * ip_port);*/
|
||||
}; // g_conv_manager;
|
||||
|
||||
erase_conv(conv);
|
||||
if(info==0)
|
||||
{
|
||||
mylog(log_info,"conv %x cleared\n",conv);
|
||||
}
|
||||
else
|
||||
{
|
||||
mylog(log_info,"[%s]conv %x cleared\n",info,conv);
|
||||
}
|
||||
cnt++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
conv_manager_t();
|
||||
~conv_manager_t();
|
||||
int get_size();
|
||||
void reserve();
|
||||
void clear();
|
||||
u32_t get_new_conv();
|
||||
int is_conv_used(u32_t conv);
|
||||
int is_u64_used(T u64);
|
||||
u32_t find_conv_by_u64(T u64);
|
||||
T find_u64_by_conv(u32_t conv);
|
||||
int update_active_time(u32_t conv);
|
||||
int insert_conv(u32_t conv,T u64);
|
||||
int erase_conv(u32_t conv);
|
||||
int clear_inactive(char * ip_port=0);
|
||||
int clear_inactive0(char * ip_port);*/
|
||||
};//g_conv_manager;
|
||||
|
||||
struct blob_t:not_copy_able_t //used in conn_info_t.
|
||||
struct blob_t : not_copy_able_t // used in conn_info_t.
|
||||
{
|
||||
union tmp_union_t//conv_manager_t is here to avoid copying when a connection is recovered
|
||||
{
|
||||
conv_manager_t<address_t> c;
|
||||
conv_manager_t<u64_t> s;
|
||||
//avoid templates here and there, avoid pointer and type cast
|
||||
tmp_union_t()
|
||||
{
|
||||
if(program_mode==client_mode)
|
||||
{
|
||||
new( &c ) conv_manager_t<address_t>();
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(program_mode==server_mode);
|
||||
new( &s ) conv_manager_t<u64_t>();
|
||||
}
|
||||
}
|
||||
~tmp_union_t()
|
||||
{
|
||||
if(program_mode==client_mode)
|
||||
{
|
||||
c.~conv_manager_t<address_t>();
|
||||
}
|
||||
else
|
||||
{
|
||||
assert(program_mode==server_mode);
|
||||
s.~conv_manager_t<u64_t>();
|
||||
}
|
||||
}
|
||||
}conv_manager;
|
||||
union tmp_union_t // conv_manager_t is here to avoid copying when a connection is recovered
|
||||
{
|
||||
conv_manager_t<address_t> c;
|
||||
conv_manager_t<u64_t> s;
|
||||
// avoid templates here and there, avoid pointer and type cast
|
||||
tmp_union_t() {
|
||||
if (program_mode == client_mode) {
|
||||
new (&c) conv_manager_t<address_t>();
|
||||
} else {
|
||||
assert(program_mode == server_mode);
|
||||
new (&s) conv_manager_t<u64_t>();
|
||||
}
|
||||
}
|
||||
~tmp_union_t() {
|
||||
if (program_mode == client_mode) {
|
||||
c.~conv_manager_t<address_t>();
|
||||
} else {
|
||||
assert(program_mode == server_mode);
|
||||
s.~conv_manager_t<u64_t>();
|
||||
}
|
||||
}
|
||||
} conv_manager;
|
||||
|
||||
anti_replay_t anti_replay;//anti_replay_t is here bc its huge,its allocation is delayed.
|
||||
anti_replay_t anti_replay; // anti_replay_t is here bc its huge,its allocation is delayed.
|
||||
};
|
||||
struct conn_info_t //stores info for a raw connection.for client ,there is only one connection,for server there can be thousand of connection since server can
|
||||
//handle multiple clients
|
||||
struct conn_info_t // stores info for a raw connection.for client ,there is only one connection,for server there can be thousand of connection since server can
|
||||
// handle multiple clients
|
||||
{
|
||||
current_state_t state;
|
||||
current_state_t state;
|
||||
|
||||
raw_info_t raw_info;
|
||||
u64_t last_state_time;
|
||||
u64_t last_hb_sent_time; //client re-use this for retry
|
||||
u64_t last_hb_recv_time;
|
||||
//long long last_resent_time;
|
||||
raw_info_t raw_info;
|
||||
u64_t last_state_time;
|
||||
u64_t last_hb_sent_time; // client re-use this for retry
|
||||
u64_t last_hb_recv_time;
|
||||
// long long last_resent_time;
|
||||
|
||||
my_id_t my_id;
|
||||
my_id_t oppsite_id;
|
||||
my_id_t my_id;
|
||||
my_id_t oppsite_id;
|
||||
|
||||
fd64_t timer_fd64;
|
||||
fd64_t udp_fd64;
|
||||
|
||||
fd64_t timer_fd64;
|
||||
fd64_t udp_fd64;
|
||||
my_id_t oppsite_const_id;
|
||||
|
||||
my_id_t oppsite_const_id;
|
||||
blob_t *blob;
|
||||
|
||||
blob_t *blob;
|
||||
uint8_t my_roller;
|
||||
uint8_t oppsite_roller;
|
||||
u64_t last_oppsite_roller_time;
|
||||
|
||||
uint8_t my_roller;
|
||||
uint8_t oppsite_roller;
|
||||
u64_t last_oppsite_roller_time;
|
||||
// ip_port_t ip_port;
|
||||
|
||||
// ip_port_t ip_port;
|
||||
/*
|
||||
const uint32_t &ip=raw_info.recv_info.src_ip;
|
||||
const uint16_t &port=raw_info.recv_info.src_port;
|
||||
|
||||
/*
|
||||
const uint32_t &ip=raw_info.recv_info.src_ip;
|
||||
const uint16_t &port=raw_info.recv_info.src_port;
|
||||
*/
|
||||
void recover(const conn_info_t &conn_info);
|
||||
void re_init();
|
||||
conn_info_t();
|
||||
void prepare();
|
||||
conn_info_t(const conn_info_t &b);
|
||||
conn_info_t &operator=(const conn_info_t &b);
|
||||
~conn_info_t();
|
||||
}; // g_conn_info;
|
||||
|
||||
*/
|
||||
void recover(const conn_info_t &conn_info);
|
||||
void re_init();
|
||||
conn_info_t();
|
||||
void prepare();
|
||||
conn_info_t(const conn_info_t&b);
|
||||
conn_info_t& operator=(const conn_info_t& b);
|
||||
~conn_info_t();
|
||||
};//g_conn_info;
|
||||
|
||||
struct conn_manager_t //manager for connections. for client,we dont need conn_manager since there is only one connection.for server we use one conn_manager for all connections
|
||||
struct conn_manager_t // manager for connections. for client,we dont need conn_manager since there is only one connection.for server we use one conn_manager for all connections
|
||||
{
|
||||
u32_t ready_num;
|
||||
|
||||
u32_t ready_num;
|
||||
// unordered_map<int,conn_info_t *> udp_fd_mp; //a bit dirty to used pointer,but can void unordered_map search
|
||||
// unordered_map<int,conn_info_t *> timer_fd_mp;//we can use pointer here since unordered_map.rehash() uses shallow copy
|
||||
|
||||
//unordered_map<int,conn_info_t *> udp_fd_mp; //a bit dirty to used pointer,but can void unordered_map search
|
||||
//unordered_map<int,conn_info_t *> timer_fd_mp;//we can use pointer here since unordered_map.rehash() uses shallow copy
|
||||
unordered_map<my_id_t, conn_info_t *> const_id_mp;
|
||||
|
||||
unordered_map<my_id_t,conn_info_t *> const_id_mp;
|
||||
unordered_map<address_t, conn_info_t *> mp; // put it at end so that it de-consturcts first
|
||||
|
||||
unordered_map<address_t,conn_info_t*> mp; //put it at end so that it de-consturcts first
|
||||
// lru_collector_t<address_t> lru;
|
||||
|
||||
//lru_collector_t<address_t> lru;
|
||||
unordered_map<address_t, conn_info_t *>::iterator clear_it;
|
||||
|
||||
unordered_map<address_t,conn_info_t*>::iterator clear_it;
|
||||
long long last_clear_time;
|
||||
|
||||
long long last_clear_time;
|
||||
|
||||
conn_manager_t();
|
||||
int exist(address_t addr);
|
||||
/*
|
||||
int insert(uint32_t ip,uint16_t port)
|
||||
{
|
||||
uint64_t u64=0;
|
||||
u64=ip;
|
||||
u64<<=32u;
|
||||
u64|=port;
|
||||
mp[u64];
|
||||
return 0;
|
||||
}*/
|
||||
conn_info_t *& find_insert_p(address_t addr); //be aware,the adress may change after rehash //not true?
|
||||
conn_info_t & find_insert(address_t addr) ; //be aware,the adress may change after rehash
|
||||
|
||||
int erase(unordered_map<address_t,conn_info_t*>::iterator erase_it);
|
||||
int clear_inactive();
|
||||
int clear_inactive0();
|
||||
conn_manager_t();
|
||||
int exist(address_t addr);
|
||||
/*
|
||||
int insert(uint32_t ip,uint16_t port)
|
||||
{
|
||||
uint64_t u64=0;
|
||||
u64=ip;
|
||||
u64<<=32u;
|
||||
u64|=port;
|
||||
mp[u64];
|
||||
return 0;
|
||||
}*/
|
||||
conn_info_t *&find_insert_p(address_t addr); // be aware,the adress may change after rehash //not true?
|
||||
conn_info_t &find_insert(address_t addr); // be aware,the adress may change after rehash
|
||||
|
||||
int erase(unordered_map<address_t, conn_info_t *>::iterator erase_it);
|
||||
int clear_inactive();
|
||||
int clear_inactive0();
|
||||
};
|
||||
|
||||
extern conn_manager_t conn_manager;
|
||||
|
||||
void server_clear_function(u64_t u64);
|
||||
|
||||
int send_bare(raw_info_t &raw_info,const char* data,int len);//send function with encryption but no anti replay,this is used when client and server verifys each other
|
||||
//you have to design the protocol carefully, so that you wont be affect by relay attack
|
||||
//int reserved_parse_bare(const char *input,int input_len,char* & data,int & len); // a sub function used in recv_bare
|
||||
int recv_bare(raw_info_t &raw_info,char* & data,int & len);//recv function with encryption but no anti replay,this is used when client and server verifys each other
|
||||
//you have to design the protocol carefully, so that you wont be affect by relay attack
|
||||
int send_handshake(raw_info_t &raw_info,my_id_t id1,my_id_t id2,my_id_t id3);// a warp for send_bare for sending handshake(this is not tcp handshake) easily
|
||||
int send_safer(conn_info_t &conn_info,char type,const char* data,int len); //safer transfer function with anti-replay,when mutually verification is done.
|
||||
int send_data_safer(conn_info_t &conn_info,const char* data,int len,u32_t conv_num);//a wrap for send_safer for transfer data.
|
||||
//int reserved_parse_safer(conn_info_t &conn_info,const char * input,int input_len,char &type,char* &data,int &len);//subfunction for recv_safer,allow overlap
|
||||
int recv_safer(conn_info_t &conn_info,char &type,char* &data,int &len);///safer transfer function with anti-replay,when mutually verification is done.
|
||||
#endif /* CONNECTION_H_ */
|
||||
int send_bare(raw_info_t &raw_info, const char *data, int len); // send function with encryption but no anti replay,this is used when client and server verifys each other
|
||||
// you have to design the protocol carefully, so that you wont be affect by relay attack
|
||||
// int reserved_parse_bare(const char *input,int input_len,char* & data,int & len); // a sub function used in recv_bare
|
||||
int recv_bare(raw_info_t &raw_info, char *&data, int &len); // recv function with encryption but no anti replay,this is used when client and server verifys each other
|
||||
// you have to design the protocol carefully, so that you wont be affect by relay attack
|
||||
int send_handshake(raw_info_t &raw_info, my_id_t id1, my_id_t id2, my_id_t id3); // a warp for send_bare for sending handshake(this is not tcp handshake) easily
|
||||
int send_safer(conn_info_t &conn_info, char type, const char *data, int len); // safer transfer function with anti-replay,when mutually verification is done.
|
||||
int send_data_safer(conn_info_t &conn_info, const char *data, int len, u32_t conv_num); // a wrap for send_safer for transfer data.
|
||||
// int reserved_parse_safer(conn_info_t &conn_info,const char * input,int input_len,char &type,char* &data,int &len);//subfunction for recv_safer,allow overlap
|
||||
|
||||
// int recv_safer(conn_info_t &conn_info,char &type,char* &data,int &len);///safer transfer function with anti-replay,when mutually verification is done.
|
||||
|
||||
int recv_safer_multi(conn_info_t &conn_info, vector<char> &type_arr, vector<string> &data_arr); // new api for handle gro
|
||||
#endif /* CONNECTION_H_ */
|
||||
|
||||
@ -14,21 +14,19 @@ udp2raw tunnel，通过raw socket给UDP包加上TCP或ICMP header，进而绕过
|
||||
|
||||
**提示：**
|
||||
|
||||
udp2raw不是加速器，只是一个帮助你绕过UDP限制的工具。如果你需要UDP加速器，请看UDPspeeder。
|
||||
udp2raw不是加速器，只是一个帮助你绕过UDP限制的工具。如果你需要UDP“加速器” (改善UDP丢包)，请看UDPspeeder。
|
||||
|
||||
UDPspeeder的repo:
|
||||
|
||||
https://github.com/wangyu-/UDPspeeder
|
||||
# 支持的平台
|
||||
Linux主机，有root权限。可以是PC、android手机/平板、openwrt路由器、树莓派。主机上最好安装了iptables命令(apt/yum很容易安装)。
|
||||
Linux主机，有root权限或cap_net_raw capability.。可以是PC、android手机/平板、openwrt路由器、树莓派。主机上最好安装了iptables命令(apt/yum很容易安装)。
|
||||
|
||||
Release中提供了`amd64`、`x86`、`arm`、`mips_be`、`mips_le`的预编译binary.
|
||||
|
||||
##### 对于windows和mac用户：
|
||||
|
||||
可以用[这个repo](https://github.com/wangyu-/udp2raw-multiplatform)里的udp2raw，原生运行。
|
||||
|
||||
<del>可以把udp2raw运行在虚拟机上(网络必须是桥接模式)。可以参考： https://github.com/wangyu-/udp2raw-tunnel/wiki/在windows-mac上运行udp2raw客户端，带图形界面 </del>
|
||||
可以用[这个repo](https://github.com/wangyu-/udp2raw-multiplatform)里的udp2raw。
|
||||
|
||||
##### 对于ios和游戏主机用户：
|
||||
|
||||
@ -44,10 +42,10 @@ Release中提供了`amd64`、`x86`、`arm`、`mips_be`、`mips_le`的预编译bi
|
||||
### 心跳保活、自动重连，连接恢复
|
||||
心跳保活、自动重连，udp2raw重连可以恢复上次的连接，重连后上层连接继续有效，底层掉线上层不掉线。有效解决上层连接断开的问题。 （功能借鉴自[kcptun-raw](https://github.com/Chion82/kcptun-raw)）（**就算你拔掉网线重插，或者重新拨号获得新ip，上层应用也不会断线**）
|
||||
|
||||
### 加密 防重放攻击
|
||||
### 加密、防重放攻击
|
||||
用aes128cbc加密(或更弱的xor)，hmac-sha1(或更弱的md5/crc32/simple)做数据完整校验。用类似ipsec/openvpn的replay window机制来防止重放攻击。
|
||||
|
||||
设计目标是，即使攻击者可以监听到tunnel的所有包，可以选择性丢弃tunnel的任意包，可以重放任意包；攻击者也没办法获得tunnel承载的任何数据，也没办法向tunnel的数据流中通过包构造/包重放插入任何数据。
|
||||
[Notes on encryption](https://github.com/wangyu-/udp2raw-tunnel/wiki/Notes-on-encryption)
|
||||
|
||||
### 其他特性
|
||||
信道复用，client的udp端支持多个连接。
|
||||
@ -56,7 +54,7 @@ server支持多个client，也能正确处理多个连接的重连和连接恢
|
||||
|
||||
NAT 穿透 ，tcp icmp udp模式都支持nat穿透。
|
||||
|
||||
支持Openvz，配合finalspeed使用，可以在openvz上用tcp模式的finalspeed
|
||||
支持Openvz，配合finalspeed使用，可以在openvz上用tcp模式的finalspeed.
|
||||
|
||||
支持Openwrt，没有编译依赖，容易编译到任何平台上。
|
||||
|
||||
@ -113,10 +111,10 @@ usage:
|
||||
run as server : ./this_program -s -l server_listen_ip:server_port -r remote_address:remote_port [options]
|
||||
|
||||
common options,these options must be same on both side:
|
||||
--raw-mode <string> avaliable values:faketcp(default),udp,icmp
|
||||
--raw-mode <string> available values:faketcp(default),udp,icmp
|
||||
-k,--key <string> password to gen symetric key,default:"secret key"
|
||||
--cipher-mode <string> avaliable values:aes128cbc(default),xor,none
|
||||
--auth-mode <string> avaliable values:hmac_sha1,md5(default),crc32,simple,none
|
||||
--cipher-mode <string> available values:aes128cbc(default),xor,none
|
||||
--auth-mode <string> available values:hmac_sha1,md5(default),crc32,simple,none
|
||||
-a,--auto-rule auto add (and delete) iptables rule
|
||||
-g,--gen-rule generate iptables rule then exit,so that you can copy and
|
||||
add it manually.overrides -a
|
||||
@ -163,7 +161,7 @@ other options:
|
||||
如果要最大的安全性建议用aes128cbc+hmac_sha1。如果要运行在路由器上，建议用xor+simple，可以节省CPU。但是注意xor+simple只能骗过防火墙的包检测，不能防止真正的攻击者。
|
||||
|
||||
### `--seq-mode`
|
||||
facktcp模式并没有模拟tcp的全部。所以理论上有办法把faketcp和真正的tcp流量区分开来（虽然大部分ISP不太可能做这种程度的包检测）。seq-mode可以改变一些seq ack的行为。如果遇到了连接问题，可以尝试更改。在我这边的移动线路用3种模式都没问题。
|
||||
faketcp模式并没有模拟tcp的全部。所以理论上有办法把faketcp和真正的tcp流量区分开来（虽然大部分ISP不太可能做这种程度的包检测）。seq-mode可以改变一些seq ack的行为。如果遇到了连接问题，可以尝试更改。在我这边的移动线路用3种模式都没问题。
|
||||
|
||||
### `--keep-rule`
|
||||
定期主动检查iptables，如果udp2raw添加的iptables规则丢了，就重新添加。在一些iptables可能会被其他程序清空的情况下(比如梅林固件和openwrt的路由器)格外有用。
|
||||
@ -264,25 +262,6 @@ raw_mode: faketcp cipher_mode: aes128cbc auth_mode: md5
|
||||
[udp2raw+kcptun step_by_step教程](kcptun_step_by_step.md)
|
||||
### 中转 finalspeed
|
||||
[udp2raw+finalspeed step_by_step教程](finalspeed_step_by_step.md)
|
||||
# 如何自己编译
|
||||
[编译教程](build_guide.zh-cn.md)
|
||||
# 相关repo
|
||||
### kcptun-raw
|
||||
udp2raw was inspired by kcptun-raw,which modified kcptun to support tcp mode.
|
||||
|
||||
https://github.com/Chion82/kcptun-raw
|
||||
### relayRawSocket
|
||||
kcptun-raw was inspired by relayRawSocket. A simple udp to raw tunnel,wrote in python
|
||||
|
||||
https://github.com/linhua55/some_kcptun_tools/tree/master/relayRawSocket
|
||||
### kcpraw
|
||||
another project of kcptun with tcp mode
|
||||
|
||||
https://github.com/ccsexyz/kcpraw
|
||||
### icmptunnel
|
||||
Transparently tunnel your IP traffic through ICMP echo and reply packets.
|
||||
|
||||
https://github.com/DhavalKapil/icmptunnel
|
||||
|
||||
# wiki
|
||||
|
||||
|
||||
914
encrypt.cpp
Executable file → Normal file
914
encrypt.cpp
Executable file → Normal file
@ -10,111 +10,128 @@
|
||||
#include "common.h"
|
||||
#include "log.h"
|
||||
|
||||
//static uint64_t seq=1;
|
||||
// static uint64_t seq=1;
|
||||
|
||||
static int8_t zero_iv[]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0};//this prog use zero iv,you should make sure first block of data contains a random/nonce data
|
||||
static int8_t zero_iv[] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; // this prog use zero iv,you should make sure first block of data contains a random/nonce data
|
||||
/****
|
||||
* security of zero_iv + nonce first data block
|
||||
* https://crypto.stackexchange.com/questions/5421/using-cbc-with-a-fixed-iv-and-a-random-first-plaintext-block
|
||||
****/
|
||||
****/
|
||||
|
||||
char normal_key[16 + 100];//generated from key_string by md5. reserved for compatiblity
|
||||
const int hmac_key_len=64;//generate 512bit long keys, use first n chars when needed
|
||||
const int cipher_key_len=64;
|
||||
unsigned char hmac_key_encrypt[hmac_key_len + 100]; //key for hmac
|
||||
unsigned char hmac_key_decrypt[hmac_key_len + 100]; //key for hmac
|
||||
unsigned char cipher_key_encrypt[cipher_key_len + 100]; //key for aes etc.
|
||||
unsigned char cipher_key_decrypt[cipher_key_len + 100]; //key for aes etc.
|
||||
char normal_key[16 + 100]; // generated from key_string by md5. reserved for compatiblity
|
||||
const int hmac_key_len = 64; // generate 512bit long keys, use first n chars when needed
|
||||
const int cipher_key_len = 64;
|
||||
unsigned char hmac_key_encrypt[hmac_key_len + 100]; // key for hmac
|
||||
unsigned char hmac_key_decrypt[hmac_key_len + 100]; // key for hmac
|
||||
unsigned char cipher_key_encrypt[cipher_key_len + 100]; // key for aes etc.
|
||||
unsigned char cipher_key_decrypt[cipher_key_len + 100]; // key for aes etc.
|
||||
|
||||
unordered_map<int, const char *> auth_mode_tostring = {{auth_none, "none"}, {auth_md5, "md5"}, {auth_crc32, "crc32"},{auth_simple,"simple"},{auth_hmac_sha1,"hmac_sha1"},};
|
||||
char gro_xor[256 + 100]; // dirty fix for gro
|
||||
|
||||
unordered_map<int, const char *> cipher_mode_tostring={{cipher_none,"none"},{cipher_aes128cfb,"aes128cfb"},{cipher_aes128cbc,"aes128cbc"},{cipher_xor,"xor"},};
|
||||
//TODO aes-gcm
|
||||
unordered_map<int, const char *> auth_mode_tostring = {
|
||||
{auth_none, "none"},
|
||||
{auth_md5, "md5"},
|
||||
{auth_crc32, "crc32"},
|
||||
{auth_simple, "simple"},
|
||||
{auth_hmac_sha1, "hmac_sha1"},
|
||||
};
|
||||
|
||||
auth_mode_t auth_mode=auth_md5;
|
||||
cipher_mode_t cipher_mode=cipher_aes128cbc;
|
||||
int is_hmac_used=0;
|
||||
unordered_map<int, const char *> cipher_mode_tostring = {
|
||||
{cipher_none, "none"},
|
||||
{cipher_aes128cfb, "aes128cfb"},
|
||||
{cipher_aes128cbc, "aes128cbc"},
|
||||
{cipher_xor, "xor"},
|
||||
};
|
||||
// TODO aes-gcm
|
||||
|
||||
//TODO key negotiation and forward secrecy
|
||||
auth_mode_t auth_mode = auth_md5;
|
||||
cipher_mode_t cipher_mode = cipher_aes128cbc;
|
||||
int is_hmac_used = 0;
|
||||
|
||||
int my_init_keys(const char * user_passwd,int is_client)
|
||||
{
|
||||
char tmp[1000]="";
|
||||
int len=strlen(user_passwd);
|
||||
int aes128cfb_old = 0;
|
||||
|
||||
strcat(tmp,user_passwd);
|
||||
// TODO key negotiation and forward secrecy
|
||||
|
||||
strcat(tmp,"key1");
|
||||
int my_init_keys(const char *user_passwd, int is_client) {
|
||||
char tmp[1000] = "";
|
||||
int len = strlen(user_passwd);
|
||||
|
||||
md5((uint8_t*)tmp,strlen(tmp),(uint8_t*)normal_key);
|
||||
strcat(tmp, user_passwd);
|
||||
|
||||
if(auth_mode==auth_hmac_sha1)
|
||||
is_hmac_used=1;
|
||||
if(is_hmac_used)
|
||||
{
|
||||
unsigned char salt[400]="";
|
||||
char salt_text[400]="udp2raw_salt1";
|
||||
md5((uint8_t*)(salt_text),strlen(salt_text),salt); //TODO different salt per session
|
||||
strcat(tmp, "key1");
|
||||
|
||||
unsigned char pbkdf2_output1[400]="";
|
||||
PKCS5_PBKDF2_HMAC_SHA256((uint8_t*)user_passwd,len,salt,16,10000, 32,pbkdf2_output1); //TODO argon2 ?
|
||||
md5((uint8_t *)tmp, strlen(tmp), (uint8_t *)normal_key);
|
||||
|
||||
//unsigned char pbkdf2_output2[400]="";
|
||||
//PKCS5_PBKDF2_HMAC_SHA256(pbkdf2_output1,32,0,0,1, hmac_key_len*2+cipher_key_len*2,pbkdf2_output2); //stretch it
|
||||
if (auth_mode == auth_hmac_sha1)
|
||||
is_hmac_used = 1;
|
||||
if (is_hmac_used || g_fix_gro || 1) {
|
||||
unsigned char salt[400] = "";
|
||||
char salt_text[400] = "udp2raw_salt1";
|
||||
md5((uint8_t *)(salt_text), strlen(salt_text), salt); // TODO different salt per session
|
||||
|
||||
const char *info_hmac_encrypt="hmac_key server-->client";
|
||||
const char *info_hmac_decrypt="hmac_key client-->server";
|
||||
const char *info_cipher_encrypt="cipher_key server-->client";
|
||||
const char *info_cipher_decrypt="cipher_key client-->server";
|
||||
unsigned char pbkdf2_output1[400] = "";
|
||||
PKCS5_PBKDF2_HMAC_SHA256((uint8_t *)user_passwd, len, salt, 16, 10000, 32, pbkdf2_output1); // TODO argon2 ?
|
||||
|
||||
if(is_client)
|
||||
{
|
||||
const char *tmp;
|
||||
tmp=info_hmac_encrypt; info_hmac_encrypt=info_hmac_decrypt;info_hmac_decrypt=tmp;
|
||||
tmp=info_cipher_encrypt; info_cipher_encrypt=info_cipher_decrypt;info_cipher_decrypt=tmp;
|
||||
}
|
||||
else
|
||||
{
|
||||
//nop
|
||||
}
|
||||
// unsigned char pbkdf2_output2[400]="";
|
||||
// PKCS5_PBKDF2_HMAC_SHA256(pbkdf2_output1,32,0,0,1, hmac_key_len*2+cipher_key_len*2,pbkdf2_output2); //stretch it
|
||||
|
||||
assert( hkdf_sha256_expand( pbkdf2_output1,32, (unsigned char *)info_cipher_encrypt,strlen(info_cipher_encrypt), cipher_key_encrypt, cipher_key_len ) ==0);
|
||||
assert( hkdf_sha256_expand( pbkdf2_output1,32, (unsigned char *)info_cipher_decrypt,strlen(info_cipher_decrypt), cipher_key_decrypt, cipher_key_len ) ==0);
|
||||
assert( hkdf_sha256_expand( pbkdf2_output1,32, (unsigned char *)info_hmac_encrypt,strlen(info_hmac_encrypt), hmac_key_encrypt, hmac_key_len ) ==0);
|
||||
assert( hkdf_sha256_expand( pbkdf2_output1,32, (unsigned char *)info_hmac_decrypt,strlen(info_hmac_decrypt), hmac_key_decrypt, hmac_key_len ) ==0);
|
||||
}
|
||||
|
||||
print_binary_chars(normal_key,16);
|
||||
print_binary_chars((char *)hmac_key_encrypt,hmac_key_len);
|
||||
print_binary_chars((char *)hmac_key_decrypt,hmac_key_len);
|
||||
print_binary_chars((char *)cipher_key_encrypt,cipher_key_len);
|
||||
print_binary_chars((char *)cipher_key_decrypt,cipher_key_len);
|
||||
const char *info_hmac_encrypt = "hmac_key server-->client";
|
||||
const char *info_hmac_decrypt = "hmac_key client-->server";
|
||||
const char *info_cipher_encrypt = "cipher_key server-->client";
|
||||
const char *info_cipher_decrypt = "cipher_key client-->server";
|
||||
|
||||
return 0;
|
||||
if (is_client) {
|
||||
const char *tmp;
|
||||
tmp = info_hmac_encrypt;
|
||||
info_hmac_encrypt = info_hmac_decrypt;
|
||||
info_hmac_decrypt = tmp;
|
||||
tmp = info_cipher_encrypt;
|
||||
info_cipher_encrypt = info_cipher_decrypt;
|
||||
info_cipher_decrypt = tmp;
|
||||
} else {
|
||||
// nop
|
||||
}
|
||||
|
||||
assert(hkdf_sha256_expand(pbkdf2_output1, 32, (unsigned char *)info_cipher_encrypt, strlen(info_cipher_encrypt), cipher_key_encrypt, cipher_key_len) == 0);
|
||||
assert(hkdf_sha256_expand(pbkdf2_output1, 32, (unsigned char *)info_cipher_decrypt, strlen(info_cipher_decrypt), cipher_key_decrypt, cipher_key_len) == 0);
|
||||
assert(hkdf_sha256_expand(pbkdf2_output1, 32, (unsigned char *)info_hmac_encrypt, strlen(info_hmac_encrypt), hmac_key_encrypt, hmac_key_len) == 0);
|
||||
assert(hkdf_sha256_expand(pbkdf2_output1, 32, (unsigned char *)info_hmac_decrypt, strlen(info_hmac_decrypt), hmac_key_decrypt, hmac_key_len) == 0);
|
||||
|
||||
const char *gro_info = "gro";
|
||||
assert(hkdf_sha256_expand(pbkdf2_output1, 32, (unsigned char *)gro_info, strlen(gro_info), (unsigned char *)gro_xor, 256) == 0);
|
||||
}
|
||||
|
||||
print_binary_chars(normal_key, 16);
|
||||
print_binary_chars((char *)hmac_key_encrypt, hmac_key_len);
|
||||
print_binary_chars((char *)hmac_key_decrypt, hmac_key_len);
|
||||
print_binary_chars((char *)cipher_key_encrypt, cipher_key_len);
|
||||
print_binary_chars((char *)cipher_key_decrypt, cipher_key_len);
|
||||
|
||||
return 0;
|
||||
}
|
||||
/*
|
||||
* this function comes from http://www.hackersdelight.org/hdcodetxt/crc.c.txt
|
||||
*/
|
||||
unsigned int crc32h(unsigned char *message,int len) {
|
||||
int i, crc;
|
||||
unsigned int byte, c;
|
||||
const unsigned int g0 = 0xEDB88320, g1 = g0>>1,
|
||||
g2 = g0>>2, g3 = g0>>3, g4 = g0>>4, g5 = g0>>5,
|
||||
g6 = (g0>>6)^g0, g7 = ((g0>>6)^g0)>>1;
|
||||
unsigned int crc32h(unsigned char *message, int len) {
|
||||
int i, crc;
|
||||
unsigned int byte, c;
|
||||
const unsigned int g0 = 0xEDB88320, g1 = g0 >> 1,
|
||||
g2 = g0 >> 2, g3 = g0 >> 3, g4 = g0 >> 4, g5 = g0 >> 5,
|
||||
g6 = (g0 >> 6) ^ g0, g7 = ((g0 >> 6) ^ g0) >> 1;
|
||||
|
||||
i = 0;
|
||||
crc = 0xFFFFFFFF;
|
||||
while (i!=len) { // Get next byte.
|
||||
byte = message[i];
|
||||
crc = crc ^ byte;
|
||||
c = ((crc<<31>>31) & g7) ^ ((crc<<30>>31) & g6) ^
|
||||
((crc<<29>>31) & g5) ^ ((crc<<28>>31) & g4) ^
|
||||
((crc<<27>>31) & g3) ^ ((crc<<26>>31) & g2) ^
|
||||
((crc<<25>>31) & g1) ^ ((crc<<24>>31) & g0);
|
||||
crc = ((unsigned)crc >> 8) ^ c;
|
||||
i = i + 1;
|
||||
}
|
||||
return ~crc;
|
||||
i = 0;
|
||||
crc = 0xFFFFFFFF;
|
||||
while (i != len) { // Get next byte.
|
||||
byte = message[i];
|
||||
crc = crc ^ byte;
|
||||
c = ((crc << 31 >> 31) & g7) ^ ((crc << 30 >> 31) & g6) ^
|
||||
((crc << 29 >> 31) & g5) ^ ((crc << 28 >> 31) & g4) ^
|
||||
((crc << 27 >> 31) & g3) ^ ((crc << 26 >> 31) & g2) ^
|
||||
((crc << 25 >> 31) & g1) ^ ((crc << 24 >> 31) & g0);
|
||||
crc = ((unsigned)crc >> 8) ^ c;
|
||||
i = i + 1;
|
||||
}
|
||||
return ~crc;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -122,393 +139,450 @@ unsigned int crc32h(unsigned char *message,int len) {
|
||||
memset(res,0,sizeof(int));
|
||||
for(int i=0,j=0;i<len;i++,j++)
|
||||
{
|
||||
if(j==4) j=0;
|
||||
res[j]+=data[i];
|
||||
if(j==4) j=0;
|
||||
res[j]+=data[i];
|
||||
}
|
||||
|
||||
return ;
|
||||
}*/
|
||||
|
||||
void simple_hash(unsigned char *str,int len,unsigned char res[8]) //djb2+ sdbm
|
||||
void simple_hash(unsigned char *str, int len, unsigned char res[8]) // djb2+ sdbm
|
||||
{
|
||||
u32_t hash = 5381;
|
||||
u32_t hash2 = 0;
|
||||
int c;
|
||||
int i=0;
|
||||
while(c = *str++,i++!=len)
|
||||
{
|
||||
u32_t hash = 5381;
|
||||
u32_t hash2 = 0;
|
||||
int c;
|
||||
int i = 0;
|
||||
while (c = *str++, i++ != len) {
|
||||
// hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
|
||||
hash = ((hash << 5) + hash)^c; /* (hash * 33) ^ c */
|
||||
hash2 = c + (hash2 << 6) + (hash2 << 16) - hash2;
|
||||
hash = ((hash << 5) + hash) ^ c; /* (hash * 33) ^ c */
|
||||
hash2 = c + (hash2 << 6) + (hash2 << 16) - hash2;
|
||||
}
|
||||
|
||||
hash=htonl(hash);
|
||||
hash2=htonl(hash2);
|
||||
memcpy(res,&hash,sizeof(hash));
|
||||
memcpy(res+sizeof(hash),&hash2,sizeof(hash2));
|
||||
}
|
||||
|
||||
int auth_md5_cal(const char *data,char * output,int &len)
|
||||
{
|
||||
memcpy(output,data,len);//TODO inefficient code
|
||||
md5((unsigned char *)output,len,(unsigned char *)(output+len));
|
||||
len+=16;
|
||||
return 0;
|
||||
hash = htonl(hash);
|
||||
hash2 = htonl(hash2);
|
||||
memcpy(res, &hash, sizeof(hash));
|
||||
memcpy(res + sizeof(hash), &hash2, sizeof(hash2));
|
||||
}
|
||||
|
||||
int auth_hmac_sha1_cal(const char *data,char * output,int &len)
|
||||
{
|
||||
mylog(log_trace,"auth_hmac_sha1_cal() is called\n");
|
||||
memcpy(output,data,len);//TODO inefficient code
|
||||
sha1_hmac(hmac_key_encrypt, 20, (const unsigned char *)data, len,(unsigned char *)(output+len));
|
||||
//use key len of 20 instead of hmac_key_len, "extra length would not significantly increase the function strength" (rfc2104)
|
||||
len+=20;
|
||||
return 0;
|
||||
int auth_md5_cal(const char *data, char *output, int &len) {
|
||||
memcpy(output, data, len); // TODO inefficient code
|
||||
md5((unsigned char *)output, len, (unsigned char *)(output + len));
|
||||
len += 16;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int auth_hmac_sha1_verify(const char *data,int &len)
|
||||
{
|
||||
mylog(log_trace,"auth_hmac_sha1_verify() is called\n");
|
||||
if(len<20)
|
||||
{
|
||||
mylog(log_trace,"auth_hmac_sha1_verify len<20\n");
|
||||
return -1;
|
||||
}
|
||||
char res[20];
|
||||
|
||||
sha1_hmac(hmac_key_decrypt, 20, (const unsigned char *)data, len-20,(unsigned char *)(res));
|
||||
|
||||
if(memcmp(res,data+len-20,20)!=0)
|
||||
{
|
||||
mylog(log_trace,"auth_hmac_sha1 check failed\n");
|
||||
return -2;
|
||||
}
|
||||
len-=20;
|
||||
return 0;
|
||||
int auth_hmac_sha1_cal(const char *data, char *output, int &len) {
|
||||
mylog(log_trace, "auth_hmac_sha1_cal() is called\n");
|
||||
memcpy(output, data, len); // TODO inefficient code
|
||||
sha1_hmac(hmac_key_encrypt, 20, (const unsigned char *)data, len, (unsigned char *)(output + len));
|
||||
// use key len of 20 instead of hmac_key_len, "extra length would not significantly increase the function strength" (rfc2104)
|
||||
len += 20;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int auth_crc32_cal(const char *data,char * output,int &len)
|
||||
{
|
||||
memcpy(output,data,len);//TODO inefficient code
|
||||
unsigned int ret=crc32h((unsigned char *)output,len);
|
||||
unsigned int ret_n=htonl(ret);
|
||||
memcpy(output+len,&ret_n,sizeof(unsigned int));
|
||||
len+=sizeof(unsigned int);
|
||||
return 0;
|
||||
int auth_hmac_sha1_verify(const char *data, int &len) {
|
||||
mylog(log_trace, "auth_hmac_sha1_verify() is called\n");
|
||||
if (len < 20) {
|
||||
mylog(log_trace, "auth_hmac_sha1_verify len<20\n");
|
||||
return -1;
|
||||
}
|
||||
char res[20];
|
||||
|
||||
sha1_hmac(hmac_key_decrypt, 20, (const unsigned char *)data, len - 20, (unsigned char *)(res));
|
||||
|
||||
if (memcmp(res, data + len - 20, 20) != 0) {
|
||||
mylog(log_trace, "auth_hmac_sha1 check failed\n");
|
||||
return -2;
|
||||
}
|
||||
len -= 20;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int auth_simple_cal(const char *data,char * output,int &len)
|
||||
{
|
||||
//char res[4];
|
||||
memcpy(output,data,len);//TODO inefficient code
|
||||
simple_hash((unsigned char *)output,len,(unsigned char *)(output+len));
|
||||
len+=8;
|
||||
return 0;
|
||||
}
|
||||
int auth_simple_verify(const char *data,int &len)
|
||||
{
|
||||
if(len<8) return -1;
|
||||
unsigned char res[8];
|
||||
len-=8;
|
||||
simple_hash((unsigned char *)data,len,res);
|
||||
if(memcmp(res,data+len,8)!=0)
|
||||
return -1;
|
||||
return 0;
|
||||
int auth_crc32_cal(const char *data, char *output, int &len) {
|
||||
memcpy(output, data, len); // TODO inefficient code
|
||||
unsigned int ret = crc32h((unsigned char *)output, len);
|
||||
unsigned int ret_n = htonl(ret);
|
||||
memcpy(output + len, &ret_n, sizeof(unsigned int));
|
||||
len += sizeof(unsigned int);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
int auth_none_cal(const char *data,char * output,int &len)
|
||||
{
|
||||
memcpy(output,data,len);
|
||||
return 0;
|
||||
int auth_simple_cal(const char *data, char *output, int &len) {
|
||||
// char res[4];
|
||||
memcpy(output, data, len); // TODO inefficient code
|
||||
simple_hash((unsigned char *)output, len, (unsigned char *)(output + len));
|
||||
len += 8;
|
||||
return 0;
|
||||
}
|
||||
int auth_md5_verify(const char *data,int &len)
|
||||
{
|
||||
if(len<16)
|
||||
{
|
||||
mylog(log_trace,"auth_md5_verify len<16\n");
|
||||
return -1;
|
||||
}
|
||||
char md5_res[16];
|
||||
|
||||
md5((unsigned char *)data,len-16,(unsigned char *)md5_res);
|
||||
|
||||
if(memcmp(md5_res,data+len-16,16)!=0)
|
||||
{
|
||||
mylog(log_trace,"auth_md5_verify md5 check failed\n");
|
||||
return -2;
|
||||
}
|
||||
len-=16;
|
||||
return 0;
|
||||
}
|
||||
int auth_none_verify(const char *data,int &len)
|
||||
{
|
||||
return 0;
|
||||
int auth_simple_verify(const char *data, int &len) {
|
||||
if (len < 8) return -1;
|
||||
unsigned char res[8];
|
||||
len -= 8;
|
||||
simple_hash((unsigned char *)data, len, res);
|
||||
if (memcmp(res, data + len, 8) != 0)
|
||||
return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int cipher_xor_encrypt(const char * data, char *output,int &len, char *key) {
|
||||
int i, j;
|
||||
for (i = 0, j = 0; i < len; i++, j++) {
|
||||
if(j==16) j=0;
|
||||
output[i] = data[i]^key[j];
|
||||
}
|
||||
return 0;
|
||||
int auth_none_cal(const char *data, char *output, int &len) {
|
||||
memcpy(output, data, len);
|
||||
return 0;
|
||||
}
|
||||
int cipher_xor_decrypt(const char * data, char *output,int &len, char *key) {
|
||||
int i, j;
|
||||
//char tmp[buf_len];
|
||||
//len=len/16*16+1;
|
||||
//AES128_CBC_decrypt_buffer((uint8_t *)tmp, (uint8_t *)input, len, (uint8_t *)key, (uint8_t *)iv);
|
||||
//for(i=0;i<len;i++)
|
||||
//input[i]=tmp[i];
|
||||
for (i = 0, j = 0; i < len; i++, j++) {
|
||||
if(j==16) j=0;
|
||||
output[i] = data[i]^key[j];
|
||||
}
|
||||
return 0;
|
||||
int auth_md5_verify(const char *data, int &len) {
|
||||
if (len < 16) {
|
||||
mylog(log_trace, "auth_md5_verify len<16\n");
|
||||
return -1;
|
||||
}
|
||||
char md5_res[16];
|
||||
|
||||
md5((unsigned char *)data, len - 16, (unsigned char *)md5_res);
|
||||
|
||||
if (memcmp(md5_res, data + len - 16, 16) != 0) {
|
||||
mylog(log_trace, "auth_md5_verify md5 check failed\n");
|
||||
return -2;
|
||||
}
|
||||
len -= 16;
|
||||
return 0;
|
||||
}
|
||||
int auth_none_verify(const char *data, int &len) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
int padding(char *data ,int &data_len,int padding_num)
|
||||
{
|
||||
int old_len=data_len;
|
||||
data_len+=1;
|
||||
if(data_len%padding_num!=0)
|
||||
{
|
||||
data_len= (data_len/padding_num)*padding_num+padding_num;
|
||||
}
|
||||
unsigned char * p= (unsigned char *)&data[data_len-1];
|
||||
*p= (data_len-old_len);
|
||||
return 0;
|
||||
int cipher_xor_encrypt(const char *data, char *output, int &len, char *key) {
|
||||
int i, j;
|
||||
for (i = 0, j = 0; i < len; i++, j++) {
|
||||
if (j == 16) j = 0;
|
||||
output[i] = data[i] ^ key[j];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int cipher_xor_decrypt(const char *data, char *output, int &len, char *key) {
|
||||
int i, j;
|
||||
// char tmp[buf_len];
|
||||
// len=len/16*16+1;
|
||||
// AES128_CBC_decrypt_buffer((uint8_t *)tmp, (uint8_t *)input, len, (uint8_t *)key, (uint8_t *)iv);
|
||||
// for(i=0;i<len;i++)
|
||||
// input[i]=tmp[i];
|
||||
for (i = 0, j = 0; i < len; i++, j++) {
|
||||
if (j == 16) j = 0;
|
||||
output[i] = data[i] ^ key[j];
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int de_padding(const char *data ,int &data_len,int padding_num)
|
||||
{
|
||||
if((uint8_t)data[data_len-1] >padding_num) return -1;
|
||||
data_len-=(uint8_t)data[data_len-1];
|
||||
if(data_len<0)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int cipher_aes128cbc_encrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
static int first_time=1;
|
||||
|
||||
char buf[buf_len];
|
||||
memcpy(buf,data,len);//TODO inefficient code
|
||||
|
||||
if(padding(buf,len,16)<0) return -1;
|
||||
|
||||
if(aes_key_optimize)
|
||||
{
|
||||
if(first_time==0) key=0;
|
||||
else first_time=0;
|
||||
}
|
||||
|
||||
AES_CBC_encrypt_buffer((unsigned char *)output,(unsigned char *)buf,len,(unsigned char *)key,(unsigned char *)zero_iv);
|
||||
return 0;
|
||||
}
|
||||
int cipher_aes128cfb_encrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
static int first_time=1;
|
||||
|
||||
char buf[buf_len];
|
||||
memcpy(buf,data,len);//TODO inefficient code
|
||||
if(aes_key_optimize)
|
||||
{
|
||||
if(first_time==0) key=0;
|
||||
else first_time=0;
|
||||
}
|
||||
|
||||
AES_CFB_encrypt_buffer((unsigned char *)output,(unsigned char *)buf,len,(unsigned char *)key,(unsigned char *)zero_iv);
|
||||
return 0;
|
||||
}
|
||||
int auth_crc32_verify(const char *data,int &len)
|
||||
{
|
||||
if(len<int(sizeof(unsigned int)))
|
||||
{
|
||||
mylog(log_debug,"auth_crc32_verify len<%d\n",int(sizeof(unsigned int)));
|
||||
return -1;
|
||||
}
|
||||
unsigned int ret=crc32h((unsigned char *)data,len-sizeof(unsigned int));
|
||||
unsigned int ret_n=htonl(ret);
|
||||
|
||||
if(memcmp(data+len-sizeof(unsigned int),&ret_n,sizeof(unsigned int))!=0)
|
||||
{
|
||||
mylog(log_debug,"auth_crc32_verify memcmp fail\n");
|
||||
return -1;
|
||||
}
|
||||
len-=sizeof(unsigned int);
|
||||
return 0;
|
||||
}
|
||||
int cipher_none_encrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
memcpy(output,data,len);
|
||||
return 0;
|
||||
}
|
||||
int cipher_aes128cbc_decrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
static int first_time=1;
|
||||
if(len%16 !=0) {mylog(log_debug,"len%%16!=0\n");return -1;}
|
||||
if(aes_key_optimize)
|
||||
{
|
||||
if(first_time==0) key=0;
|
||||
else first_time=0;
|
||||
}
|
||||
AES_CBC_decrypt_buffer((unsigned char *)output,(unsigned char *)data,len,(unsigned char *)key,(unsigned char *)zero_iv);
|
||||
if(de_padding(output,len,16)<0) return -1;
|
||||
return 0;
|
||||
}
|
||||
int cipher_aes128cfb_decrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
static int first_time=1;
|
||||
if(aes_key_optimize)
|
||||
{
|
||||
if(first_time==0) key=0;
|
||||
else first_time=0;
|
||||
}
|
||||
AES_CFB_decrypt_buffer((unsigned char *)output,(unsigned char *)data,len,(unsigned char *)key,(unsigned char *)zero_iv);
|
||||
//if(de_padding(output,len,16)<0) return -1;
|
||||
return 0;
|
||||
int padding(char *data, int &data_len, int padding_num) {
|
||||
int old_len = data_len;
|
||||
data_len += 1;
|
||||
if (data_len % padding_num != 0) {
|
||||
data_len = (data_len / padding_num) * padding_num + padding_num;
|
||||
}
|
||||
unsigned char *p = (unsigned char *)&data[data_len - 1];
|
||||
*p = (data_len - old_len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int cipher_none_decrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
memcpy(output,data,len);
|
||||
return 0;
|
||||
int de_padding(const char *data, int &data_len, int padding_num) {
|
||||
if (data_len == 0) return -1;
|
||||
if ((uint8_t)data[data_len - 1] > padding_num) return -1;
|
||||
data_len -= (uint8_t)data[data_len - 1];
|
||||
if (data_len < 0) {
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
void aes_ecb_encrypt(const char *data, char *output) {
|
||||
static int first_time = 1;
|
||||
char *key = (char *)cipher_key_encrypt;
|
||||
if (aes_key_optimize) {
|
||||
if (first_time == 0)
|
||||
key = 0;
|
||||
else
|
||||
first_time = 0;
|
||||
}
|
||||
AES_ECB_encrypt_buffer((uint8_t *)data, (uint8_t *)key, (uint8_t *)output);
|
||||
}
|
||||
void aes_ecb_encrypt1(char *data) {
|
||||
char buf[16];
|
||||
memcpy(buf, data, 16);
|
||||
aes_ecb_encrypt(buf, data);
|
||||
}
|
||||
void aes_ecb_decrypt(const char *data, char *output) {
|
||||
static int first_time = 1;
|
||||
char *key = (char *)cipher_key_decrypt;
|
||||
if (aes_key_optimize) {
|
||||
if (first_time == 0)
|
||||
key = 0;
|
||||
else
|
||||
first_time = 0;
|
||||
}
|
||||
AES_ECB_decrypt_buffer((uint8_t *)data, (uint8_t *)key, (uint8_t *)output);
|
||||
}
|
||||
void aes_ecb_decrypt1(char *data) {
|
||||
char buf[16];
|
||||
memcpy(buf, data, 16);
|
||||
aes_ecb_decrypt(buf, data);
|
||||
}
|
||||
int cipher_aes128cbc_encrypt(const char *data, char *output, int &len, char *key) {
|
||||
static int first_time = 1;
|
||||
|
||||
char buf[buf_len];
|
||||
memcpy(buf, data, len); // TODO inefficient code
|
||||
|
||||
if (padding(buf, len, 16) < 0) return -1;
|
||||
|
||||
if (aes_key_optimize) {
|
||||
if (first_time == 0)
|
||||
key = 0;
|
||||
else
|
||||
first_time = 0;
|
||||
}
|
||||
|
||||
AES_CBC_encrypt_buffer((unsigned char *)output, (unsigned char *)buf, len, (unsigned char *)key, (unsigned char *)zero_iv);
|
||||
return 0;
|
||||
}
|
||||
int cipher_aes128cfb_encrypt(const char *data, char *output, int &len, char *key) {
|
||||
static int first_time = 1;
|
||||
assert(len >= 16);
|
||||
|
||||
char buf[buf_len];
|
||||
memcpy(buf, data, len); // TODO inefficient code
|
||||
if (aes_key_optimize) {
|
||||
if (first_time == 0)
|
||||
key = 0;
|
||||
else
|
||||
first_time = 0;
|
||||
}
|
||||
if (!aes128cfb_old) {
|
||||
aes_ecb_encrypt(data, buf); // encrypt the first block
|
||||
}
|
||||
|
||||
AES_CFB_encrypt_buffer((unsigned char *)output, (unsigned char *)buf, len, (unsigned char *)key, (unsigned char *)zero_iv);
|
||||
return 0;
|
||||
}
|
||||
int auth_crc32_verify(const char *data, int &len) {
|
||||
if (len < int(sizeof(unsigned int))) {
|
||||
mylog(log_debug, "auth_crc32_verify len<%d\n", int(sizeof(unsigned int)));
|
||||
return -1;
|
||||
}
|
||||
unsigned int ret = crc32h((unsigned char *)data, len - sizeof(unsigned int));
|
||||
unsigned int ret_n = htonl(ret);
|
||||
|
||||
if (memcmp(data + len - sizeof(unsigned int), &ret_n, sizeof(unsigned int)) != 0) {
|
||||
mylog(log_debug, "auth_crc32_verify memcmp fail\n");
|
||||
return -1;
|
||||
}
|
||||
len -= sizeof(unsigned int);
|
||||
return 0;
|
||||
}
|
||||
int cipher_none_encrypt(const char *data, char *output, int &len, char *key) {
|
||||
memcpy(output, data, len);
|
||||
return 0;
|
||||
}
|
||||
int cipher_aes128cbc_decrypt(const char *data, char *output, int &len, char *key) {
|
||||
static int first_time = 1;
|
||||
if (len % 16 != 0) {
|
||||
mylog(log_debug, "len%%16!=0\n");
|
||||
return -1;
|
||||
}
|
||||
if (aes_key_optimize) {
|
||||
if (first_time == 0)
|
||||
key = 0;
|
||||
else
|
||||
first_time = 0;
|
||||
}
|
||||
AES_CBC_decrypt_buffer((unsigned char *)output, (unsigned char *)data, len, (unsigned char *)key, (unsigned char *)zero_iv);
|
||||
if (de_padding(output, len, 16) < 0) return -1;
|
||||
return 0;
|
||||
}
|
||||
int cipher_aes128cfb_decrypt(const char *data, char *output, int &len, char *key) {
|
||||
static int first_time = 1;
|
||||
if (len < 16) return -1;
|
||||
|
||||
if (aes_key_optimize) {
|
||||
if (first_time == 0)
|
||||
key = 0;
|
||||
else
|
||||
first_time = 0;
|
||||
}
|
||||
|
||||
AES_CFB_decrypt_buffer((unsigned char *)output, (unsigned char *)data, len, (unsigned char *)key, (unsigned char *)zero_iv);
|
||||
|
||||
if (!aes128cfb_old)
|
||||
aes_ecb_decrypt1(output); // decrypt the first block
|
||||
// if(de_padding(output,len,16)<0) return -1;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int auth_cal(const char *data,char * output,int &len)
|
||||
{
|
||||
mylog(log_trace,"auth:%d\n",auth_mode);
|
||||
switch(auth_mode)
|
||||
{
|
||||
case auth_crc32:return auth_crc32_cal(data, output, len);
|
||||
case auth_md5:return auth_md5_cal(data, output, len);
|
||||
case auth_simple:return auth_simple_cal(data, output, len);
|
||||
case auth_none:return auth_none_cal(data, output, len);
|
||||
case auth_hmac_sha1:return auth_hmac_sha1_cal(data,output,len);
|
||||
//default: return auth_md5_cal(data,output,len);//default;
|
||||
default: assert(0==1);
|
||||
}
|
||||
return -1;
|
||||
|
||||
}
|
||||
int auth_verify(const char *data,int &len)
|
||||
{
|
||||
mylog(log_trace,"auth:%d\n",auth_mode);
|
||||
switch(auth_mode)
|
||||
{
|
||||
case auth_crc32:return auth_crc32_verify(data, len);
|
||||
case auth_md5:return auth_md5_verify(data, len);
|
||||
case auth_simple:return auth_simple_verify(data, len);
|
||||
case auth_none:return auth_none_verify(data, len);
|
||||
case auth_hmac_sha1:return auth_hmac_sha1_verify(data,len);
|
||||
//default: return auth_md5_verify(data,len);//default
|
||||
default: assert(0==1);
|
||||
}
|
||||
return -1;
|
||||
|
||||
}
|
||||
int cipher_encrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
mylog(log_trace,"cipher:%d\n",cipher_mode);
|
||||
switch(cipher_mode)
|
||||
{
|
||||
case cipher_aes128cbc:return cipher_aes128cbc_encrypt(data,output,len, key);
|
||||
case cipher_aes128cfb:return cipher_aes128cfb_encrypt(data,output,len, key);
|
||||
case cipher_xor:return cipher_xor_encrypt(data,output,len, key);
|
||||
case cipher_none:return cipher_none_encrypt(data,output,len, key);
|
||||
//default:return cipher_aes128cbc_encrypt(data,output,len, key);
|
||||
default: assert(0==1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int cipher_decrypt(const char *data,char *output,int &len,char * key)
|
||||
{
|
||||
mylog(log_trace,"cipher:%d\n",cipher_mode);
|
||||
switch(cipher_mode)
|
||||
{
|
||||
case cipher_aes128cbc:return cipher_aes128cbc_decrypt(data,output,len, key);
|
||||
case cipher_aes128cfb:return cipher_aes128cfb_decrypt(data,output,len, key);
|
||||
case cipher_xor:return cipher_xor_decrypt(data,output,len, key);
|
||||
case cipher_none:return cipher_none_decrypt(data,output,len, key);
|
||||
// default: return cipher_aes128cbc_decrypt(data,output,len,key);
|
||||
default: assert(0==1);
|
||||
}
|
||||
return -1;
|
||||
int cipher_none_decrypt(const char *data, char *output, int &len, char *key) {
|
||||
memcpy(output, data, len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int encrypt_AE(const char *data,char *output,int &len /*,char * key*/)
|
||||
{
|
||||
mylog(log_trace,"encrypt_AE is called\n");
|
||||
char buf[buf_len];
|
||||
char buf2[buf_len];
|
||||
memcpy(buf,data,len);
|
||||
if(cipher_encrypt(buf,buf2,len,(char *)cipher_key_encrypt) !=0) {mylog(log_debug,"cipher_encrypt failed ");return -1;}
|
||||
if(auth_cal(buf2,output,len)!=0) {mylog(log_debug,"auth_cal failed ");return -1;}
|
||||
|
||||
//printf("%d %x %x\n",len,(int)(output[0]),(int)(output[1]));
|
||||
//print_binary_chars(output,len);
|
||||
|
||||
//use encrypt-then-MAC scheme
|
||||
return 0;
|
||||
int auth_cal(const char *data, char *output, int &len) {
|
||||
mylog(log_trace, "auth:%d\n", auth_mode);
|
||||
switch (auth_mode) {
|
||||
case auth_crc32:
|
||||
return auth_crc32_cal(data, output, len);
|
||||
case auth_md5:
|
||||
return auth_md5_cal(data, output, len);
|
||||
case auth_simple:
|
||||
return auth_simple_cal(data, output, len);
|
||||
case auth_none:
|
||||
return auth_none_cal(data, output, len);
|
||||
case auth_hmac_sha1:
|
||||
return auth_hmac_sha1_cal(data, output, len);
|
||||
// default: return auth_md5_cal(data,output,len);//default;
|
||||
default:
|
||||
assert(0 == 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int auth_verify(const char *data, int &len) {
|
||||
mylog(log_trace, "auth:%d\n", auth_mode);
|
||||
switch (auth_mode) {
|
||||
case auth_crc32:
|
||||
return auth_crc32_verify(data, len);
|
||||
case auth_md5:
|
||||
return auth_md5_verify(data, len);
|
||||
case auth_simple:
|
||||
return auth_simple_verify(data, len);
|
||||
case auth_none:
|
||||
return auth_none_verify(data, len);
|
||||
case auth_hmac_sha1:
|
||||
return auth_hmac_sha1_verify(data, len);
|
||||
// default: return auth_md5_verify(data,len);//default
|
||||
default:
|
||||
assert(0 == 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int cipher_encrypt(const char *data, char *output, int &len, char *key) {
|
||||
mylog(log_trace, "cipher:%d\n", cipher_mode);
|
||||
switch (cipher_mode) {
|
||||
case cipher_aes128cbc:
|
||||
return cipher_aes128cbc_encrypt(data, output, len, key);
|
||||
case cipher_aes128cfb:
|
||||
return cipher_aes128cfb_encrypt(data, output, len, key);
|
||||
case cipher_xor:
|
||||
return cipher_xor_encrypt(data, output, len, key);
|
||||
case cipher_none:
|
||||
return cipher_none_encrypt(data, output, len, key);
|
||||
// default:return cipher_aes128cbc_encrypt(data,output,len, key);
|
||||
default:
|
||||
assert(0 == 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
int cipher_decrypt(const char *data, char *output, int &len, char *key) {
|
||||
mylog(log_trace, "cipher:%d\n", cipher_mode);
|
||||
switch (cipher_mode) {
|
||||
case cipher_aes128cbc:
|
||||
return cipher_aes128cbc_decrypt(data, output, len, key);
|
||||
case cipher_aes128cfb:
|
||||
return cipher_aes128cfb_decrypt(data, output, len, key);
|
||||
case cipher_xor:
|
||||
return cipher_xor_decrypt(data, output, len, key);
|
||||
case cipher_none:
|
||||
return cipher_none_decrypt(data, output, len, key);
|
||||
// default: return cipher_aes128cbc_decrypt(data,output,len,key);
|
||||
default:
|
||||
assert(0 == 1);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
int decrypt_AE(const char *data,char *output,int &len /*,char * key*/)
|
||||
{
|
||||
mylog(log_trace,"decrypt_AE is called\n");
|
||||
//printf("%d %x %x\n",len,(int)(data[0]),(int)(data[1]));
|
||||
//print_binary_chars(data,len);
|
||||
int encrypt_AE(const char *data, char *output, int &len /*,char * key*/) {
|
||||
mylog(log_trace, "encrypt_AE is called\n");
|
||||
char buf[buf_len];
|
||||
char buf2[buf_len];
|
||||
memcpy(buf, data, len);
|
||||
if (cipher_encrypt(buf, buf2, len, (char *)cipher_key_encrypt) != 0) {
|
||||
mylog(log_debug, "cipher_encrypt failed ");
|
||||
return -1;
|
||||
}
|
||||
if (auth_cal(buf2, output, len) != 0) {
|
||||
mylog(log_debug, "auth_cal failed ");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(auth_verify(data,len)!=0) {mylog(log_debug,"auth_verify failed\n");return -1;}
|
||||
if(cipher_decrypt(data,output,len,(char *)cipher_key_decrypt) !=0) {mylog(log_debug,"cipher_decrypt failed \n"); return -1;}
|
||||
return 0;
|
||||
// printf("%d %x %x\n",len,(int)(output[0]),(int)(output[1]));
|
||||
// print_binary_chars(output,len);
|
||||
|
||||
// use encrypt-then-MAC scheme
|
||||
return 0;
|
||||
}
|
||||
|
||||
int my_encrypt(const char *data,char *output,int &len /*,char * key*/)
|
||||
{
|
||||
if(len<0) {mylog(log_trace,"len<0");return -1;}
|
||||
if(len>max_data_len) {mylog(log_warn,"len>max_data_len");return -1;}
|
||||
|
||||
if(is_hmac_used)
|
||||
return encrypt_AE(data,output,len);
|
||||
|
||||
|
||||
char buf[buf_len];
|
||||
char buf2[buf_len];
|
||||
memcpy(buf,data,len);
|
||||
if(auth_cal(buf,buf2,len)!=0) {mylog(log_debug,"auth_cal failed ");return -1;}
|
||||
if(cipher_encrypt(buf2,output,len,normal_key) !=0) {mylog(log_debug,"cipher_encrypt failed ");return -1;}
|
||||
return 0;
|
||||
int decrypt_AE(const char *data, char *output, int &len /*,char * key*/) {
|
||||
mylog(log_trace, "decrypt_AE is called\n");
|
||||
// printf("%d %x %x\n",len,(int)(data[0]),(int)(data[1]));
|
||||
// print_binary_chars(data,len);
|
||||
|
||||
if (auth_verify(data, len) != 0) {
|
||||
mylog(log_debug, "auth_verify failed\n");
|
||||
return -1;
|
||||
}
|
||||
if (cipher_decrypt(data, output, len, (char *)cipher_key_decrypt) != 0) {
|
||||
mylog(log_debug, "cipher_decrypt failed \n");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int my_decrypt(const char *data,char *output,int &len /*,char * key*/)
|
||||
{
|
||||
if(len<0) return -1;
|
||||
if(len>max_data_len) {mylog(log_warn,"len>max_data_len");return -1;}
|
||||
int my_encrypt(const char *data, char *output, int &len /*,char * key*/) {
|
||||
if (len < 0) {
|
||||
mylog(log_trace, "len<0");
|
||||
return -1;
|
||||
}
|
||||
if (len > max_data_len) {
|
||||
mylog(log_warn, "len>max_data_len");
|
||||
return -1;
|
||||
}
|
||||
|
||||
if(is_hmac_used)
|
||||
return decrypt_AE(data,output,len);
|
||||
if (is_hmac_used)
|
||||
return encrypt_AE(data, output, len);
|
||||
|
||||
if(cipher_decrypt(data,output,len,normal_key) !=0) {mylog(log_debug,"cipher_decrypt failed \n"); return -1;}
|
||||
if(auth_verify(output,len)!=0) {mylog(log_debug,"auth_verify failed\n");return -1;}
|
||||
|
||||
return 0;
|
||||
char buf[buf_len];
|
||||
char buf2[buf_len];
|
||||
memcpy(buf, data, len);
|
||||
if (auth_cal(buf, buf2, len) != 0) {
|
||||
mylog(log_debug, "auth_cal failed ");
|
||||
return -1;
|
||||
}
|
||||
if (cipher_encrypt(buf2, output, len, normal_key) != 0) {
|
||||
mylog(log_debug, "cipher_encrypt failed ");
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int my_decrypt(const char *data, char *output, int &len /*,char * key*/) {
|
||||
if (len < 0) return -1;
|
||||
if (len > max_data_len) {
|
||||
mylog(log_warn, "len>max_data_len");
|
||||
return -1;
|
||||
}
|
||||
|
||||
int encrypt_AEAD(uint8_t *data,uint8_t *output,int &len,uint8_t * key,uint8_t *header,int hlen)
|
||||
{
|
||||
//TODO
|
||||
return -1;
|
||||
if (is_hmac_used)
|
||||
return decrypt_AE(data, output, len);
|
||||
|
||||
if (cipher_decrypt(data, output, len, normal_key) != 0) {
|
||||
mylog(log_debug, "cipher_decrypt failed \n");
|
||||
return -1;
|
||||
}
|
||||
if (auth_verify(output, len) != 0) {
|
||||
mylog(log_debug, "auth_verify failed\n");
|
||||
return -1;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int decrypt_AEAD(uint8_t *data,uint8_t *output,int &len,uint8_t * key,uint8_t *header,int hlen)
|
||||
{
|
||||
//TODO
|
||||
return -1;
|
||||
int encrypt_AEAD(uint8_t *data, uint8_t *output, int &len, uint8_t *key, uint8_t *header, int hlen) {
|
||||
// TODO
|
||||
return -1;
|
||||
}
|
||||
|
||||
int decrypt_AEAD(uint8_t *data, uint8_t *output, int &len, uint8_t *key, uint8_t *header, int hlen) {
|
||||
// TODO
|
||||
return -1;
|
||||
}
|
||||
|
||||
44
encrypt.h
Executable file → Normal file
44
encrypt.h
Executable file → Normal file
@ -1,32 +1,35 @@
|
||||
#ifndef UDP2RAW_ENCRYPTION_H_
|
||||
#define UDP2RAW_ENCRYPTION_H_
|
||||
|
||||
|
||||
|
||||
//#include "aes.h"
|
||||
//#include "md5.h"
|
||||
#include "common.h"
|
||||
|
||||
// using namespace std;
|
||||
// extern char key[16];
|
||||
|
||||
//using namespace std;
|
||||
//extern char key[16];
|
||||
const int aes_key_optimize = 1; // if enabled,once you used a key for aes,you cant change it anymore
|
||||
extern int aes128cfb_old;
|
||||
|
||||
const int aes_key_optimize=1; //if enabled,once you used a key for aes,you cant change it anymore
|
||||
int my_init_keys(const char *, int);
|
||||
|
||||
int my_init_keys(const char *,int);
|
||||
int my_encrypt(const char *data, char *output, int &len);
|
||||
int my_decrypt(const char *data, char *output, int &len);
|
||||
|
||||
int my_encrypt(const char *data,char *output,int &len);
|
||||
int my_decrypt(const char *data,char *output,int &len);
|
||||
unsigned short csum(const unsigned short *ptr, int nbytes);
|
||||
|
||||
enum auth_mode_t { auth_none = 0,
|
||||
auth_md5,
|
||||
auth_crc32,
|
||||
auth_simple,
|
||||
auth_hmac_sha1,
|
||||
auth_end };
|
||||
|
||||
unsigned short csum(const unsigned short *ptr,int nbytes) ;
|
||||
|
||||
|
||||
enum auth_mode_t {auth_none=0,auth_md5,auth_crc32,auth_simple,auth_hmac_sha1,auth_end};
|
||||
|
||||
|
||||
enum cipher_mode_t {cipher_none=0,cipher_aes128cbc,cipher_xor,cipher_aes128cfb,cipher_end};
|
||||
|
||||
enum cipher_mode_t { cipher_none = 0,
|
||||
cipher_aes128cbc,
|
||||
cipher_xor,
|
||||
cipher_aes128cfb,
|
||||
cipher_end };
|
||||
|
||||
extern auth_mode_t auth_mode;
|
||||
extern cipher_mode_t cipher_mode;
|
||||
@ -34,10 +37,15 @@ extern cipher_mode_t cipher_mode;
|
||||
extern unordered_map<int, const char *> auth_mode_tostring;
|
||||
extern unordered_map<int, const char *> cipher_mode_tostring;
|
||||
|
||||
extern char gro_xor[256 + 100];
|
||||
|
||||
int cipher_decrypt(const char *data, char *output, int &len, char *key); // internal interface ,exposed for test only
|
||||
int cipher_encrypt(const char *data, char *output, int &len, char *key); // internal interface ,exposed for test only
|
||||
|
||||
void aes_ecb_encrypt(const char *data, char *output);
|
||||
void aes_ecb_decrypt(const char *data, char *output);
|
||||
|
||||
int cipher_decrypt(const char *data,char *output,int &len,char * key);//internal interface ,exposed for test only
|
||||
int cipher_encrypt(const char *data,char *output,int &len,char * key);//internal interface ,exposed for test only
|
||||
void aes_ecb_encrypt1(char *data);
|
||||
void aes_ecb_decrypt1(char *data);
|
||||
|
||||
#endif
|
||||
|
||||
@ -5,60 +5,49 @@
|
||||
* Author: root
|
||||
*/
|
||||
|
||||
|
||||
#include "fd_manager.h"
|
||||
int fd_manager_t::fd_exist(int fd)
|
||||
{
|
||||
return fd_to_fd64_mp.find(fd)!=fd_to_fd64_mp.end();
|
||||
int fd_manager_t::fd_exist(int fd) {
|
||||
return fd_to_fd64_mp.find(fd) != fd_to_fd64_mp.end();
|
||||
}
|
||||
int fd_manager_t::exist(fd64_t fd64)
|
||||
{
|
||||
return fd64_to_fd_mp.find(fd64)!=fd64_to_fd_mp.end();
|
||||
int fd_manager_t::exist(fd64_t fd64) {
|
||||
return fd64_to_fd_mp.find(fd64) != fd64_to_fd_mp.end();
|
||||
}
|
||||
int fd_manager_t::to_fd(fd64_t fd64)
|
||||
{
|
||||
assert(exist(fd64));
|
||||
return fd64_to_fd_mp[fd64];
|
||||
int fd_manager_t::to_fd(fd64_t fd64) {
|
||||
assert(exist(fd64));
|
||||
return fd64_to_fd_mp[fd64];
|
||||
}
|
||||
void fd_manager_t::fd64_close(fd64_t fd64)
|
||||
{
|
||||
assert(exist(fd64));
|
||||
int fd=fd64_to_fd_mp[fd64];
|
||||
fd64_to_fd_mp.erase(fd64);
|
||||
fd_to_fd64_mp.erase(fd);
|
||||
if(exist_info(fd64))
|
||||
{
|
||||
fd_info_mp.erase(fd64);
|
||||
}
|
||||
//assert(close(fd)==0);
|
||||
sock_close(fd);
|
||||
void fd_manager_t::fd64_close(fd64_t fd64) {
|
||||
assert(exist(fd64));
|
||||
int fd = fd64_to_fd_mp[fd64];
|
||||
fd64_to_fd_mp.erase(fd64);
|
||||
fd_to_fd64_mp.erase(fd);
|
||||
if (exist_info(fd64)) {
|
||||
fd_info_mp.erase(fd64);
|
||||
}
|
||||
// assert(close(fd)==0);
|
||||
sock_close(fd);
|
||||
}
|
||||
void fd_manager_t::reserve(int n)
|
||||
{
|
||||
fd_to_fd64_mp.reserve(n);
|
||||
fd64_to_fd_mp.reserve(n);
|
||||
fd_info_mp.reserve(n);
|
||||
void fd_manager_t::reserve(int n) {
|
||||
fd_to_fd64_mp.reserve(n);
|
||||
fd64_to_fd_mp.reserve(n);
|
||||
fd_info_mp.reserve(n);
|
||||
}
|
||||
u64_t fd_manager_t::create(int fd)
|
||||
{
|
||||
assert(!fd_exist(fd));
|
||||
fd64_t fd64=counter++;
|
||||
fd_to_fd64_mp[fd]=fd64;
|
||||
fd64_to_fd_mp[fd64]=fd;
|
||||
return fd64;
|
||||
u64_t fd_manager_t::create(int fd) {
|
||||
assert(!fd_exist(fd));
|
||||
fd64_t fd64 = counter++;
|
||||
fd_to_fd64_mp[fd] = fd64;
|
||||
fd64_to_fd_mp[fd64] = fd;
|
||||
return fd64;
|
||||
}
|
||||
fd_manager_t::fd_manager_t()
|
||||
{
|
||||
counter=u32_t(-1);
|
||||
counter+=100;
|
||||
reserve(10007);
|
||||
fd_manager_t::fd_manager_t() {
|
||||
counter = u32_t(-1);
|
||||
counter += 100;
|
||||
reserve(10007);
|
||||
}
|
||||
fd_info_t & fd_manager_t::get_info(fd64_t fd64)
|
||||
{
|
||||
assert(exist(fd64));
|
||||
return fd_info_mp[fd64];
|
||||
fd_info_t& fd_manager_t::get_info(fd64_t fd64) {
|
||||
assert(exist(fd64));
|
||||
return fd_info_mp[fd64];
|
||||
}
|
||||
int fd_manager_t::exist_info(fd64_t fd64)
|
||||
{
|
||||
return fd_info_mp.find(fd64)!=fd_info_mp.end();
|
||||
int fd_manager_t::exist_info(fd64_t fd64) {
|
||||
return fd_info_mp.find(fd64) != fd_info_mp.end();
|
||||
}
|
||||
|
||||
44
fd_manager.h
44
fd_manager.h
@ -12,31 +12,31 @@
|
||||
//#include "packet.h"
|
||||
#include "connection.h"
|
||||
|
||||
struct fd_info_t
|
||||
{
|
||||
//ip_port_t ip_port;
|
||||
conn_info_t *p_conn_info;
|
||||
struct fd_info_t {
|
||||
// ip_port_t ip_port;
|
||||
conn_info_t *p_conn_info;
|
||||
};
|
||||
|
||||
struct fd_manager_t //conver fd to a uniq 64bit number,avoid fd value conflict caused by close and re-create
|
||||
//this class is not strictly necessary,it just makes epoll fd handling easier
|
||||
struct fd_manager_t // conver fd to a uniq 64bit number,avoid fd value conflict caused by close and re-create
|
||||
// this class is not strictly necessary,it just makes epoll fd handling easier
|
||||
{
|
||||
fd_info_t & get_info(fd64_t fd64);
|
||||
int exist_info(fd64_t);
|
||||
int exist(fd64_t fd64);
|
||||
int to_fd(fd64_t);
|
||||
void fd64_close(fd64_t fd64);
|
||||
void reserve(int n);
|
||||
u64_t create(int fd);
|
||||
fd_manager_t();
|
||||
private:
|
||||
u64_t counter;
|
||||
unordered_map<int,fd64_t> fd_to_fd64_mp;
|
||||
unordered_map<fd64_t,int> fd64_to_fd_mp;
|
||||
unordered_map<fd64_t,fd_info_t> fd_info_mp;
|
||||
int fd_exist(int fd);
|
||||
//void remove_fd(int fd);
|
||||
//fd64_t fd_to_fd64(int fd);
|
||||
fd_info_t &get_info(fd64_t fd64);
|
||||
int exist_info(fd64_t);
|
||||
int exist(fd64_t fd64);
|
||||
int to_fd(fd64_t);
|
||||
void fd64_close(fd64_t fd64);
|
||||
void reserve(int n);
|
||||
u64_t create(int fd);
|
||||
fd_manager_t();
|
||||
|
||||
private:
|
||||
u64_t counter;
|
||||
unordered_map<int, fd64_t> fd_to_fd64_mp;
|
||||
unordered_map<fd64_t, int> fd64_to_fd_mp;
|
||||
unordered_map<fd64_t, fd_info_t> fd_info_mp;
|
||||
int fd_exist(int fd);
|
||||
// void remove_fd(int fd);
|
||||
// fd64_t fd_to_fd64(int fd);
|
||||
};
|
||||
|
||||
extern fd_manager_t fd_manager;
|
||||
|
||||
@ -7,9 +7,8 @@
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
//not used
|
||||
//void AES_ECB_encrypt(const uint8_t* input, const uint8_t* key, uint8_t *output, const uint32_t length);
|
||||
//void AES_ECB_decrypt(const uint8_t* input, const uint8_t* key, uint8_t *output, const uint32_t length);
|
||||
void AES_ECB_encrypt_buffer(const uint8_t* input, const uint8_t* key, uint8_t *output);
|
||||
void AES_ECB_decrypt_buffer(const uint8_t* input, const uint8_t* key, uint8_t *output);
|
||||
|
||||
void AES_CBC_encrypt_buffer(uint8_t* output, uint8_t* input, uint32_t length, const uint8_t* key, const uint8_t* iv);
|
||||
void AES_CBC_decrypt_buffer(uint8_t* output, uint8_t* input, uint32_t length, const uint8_t* key, const uint8_t* iv);
|
||||
|
||||
@ -366,32 +366,25 @@ void AES_CBC_decrypt_buffer(uint8_t* output, uint8_t* input, uint32_t length, co
|
||||
decrypt_cbc(rk, length, iv_tmp, input, output);
|
||||
}
|
||||
|
||||
/*
|
||||
void AES_ECB_encrypt(const uint8_t* input, const uint8_t* key, uint8_t* output, const uint32_t length)
|
||||
void AES_ECB_encrypt_buffer(const uint8_t* input, const uint8_t* key, uint8_t* output)
|
||||
{
|
||||
uint8_t rk[AES_RKSIZE];
|
||||
static uint8_t rk[AES_RKSIZE];
|
||||
|
||||
if (key == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
aeshw_init();
|
||||
setkey_enc(rk, key);
|
||||
if(key!=NULL)
|
||||
setkey_enc(rk, key);
|
||||
encrypt_ecb(AES_NR, rk, input, output);
|
||||
}
|
||||
|
||||
void AES_ECB_decrypt(const uint8_t* input, const uint8_t* key, uint8_t *output, const uint32_t length)
|
||||
void AES_ECB_decrypt_buffer(const uint8_t* input, const uint8_t* key, uint8_t *output)
|
||||
{
|
||||
uint8_t rk[AES_RKSIZE];
|
||||
static uint8_t rk[AES_RKSIZE];
|
||||
|
||||
if (key == NULL)
|
||||
{
|
||||
return;
|
||||
}
|
||||
aeshw_init();
|
||||
setkey_dec(rk, key);
|
||||
if(key!=NULL)
|
||||
setkey_dec(rk, key);
|
||||
decrypt_ecb(AES_NR, rk, input, output);
|
||||
}*/
|
||||
}
|
||||
|
||||
static void encrypt_cfb( uint8_t* rk,
|
||||
uint32_t length,size_t *iv_off,
|
||||
|
||||
@ -12,15 +12,29 @@
|
||||
#endif
|
||||
|
||||
|
||||
void AES_ECB_encrypt(const uint8_t* input, const uint8_t* key, uint8_t *output, const uint32_t length)
|
||||
void AES_ECB_encrypt_buffer(const uint8_t* input, const uint8_t* key, uint8_t *output)
|
||||
{
|
||||
printf("AES_ECB_encrypt not implemented\n");
|
||||
exit(-1);
|
||||
static aes_context ctx;
|
||||
if(key!=0)
|
||||
{
|
||||
aes_init( &ctx);
|
||||
aes_setkey_enc(&ctx,key,AES_KEYSIZE);
|
||||
}
|
||||
int ret=aes_crypt_ecb( &ctx, AES_ENCRYPT, (const unsigned char*)input,(unsigned char*) output );
|
||||
assert(ret==0);
|
||||
return ;
|
||||
}
|
||||
void AES_ECB_decrypt(const uint8_t* input, const uint8_t* key, uint8_t *output, const uint32_t length)
|
||||
void AES_ECB_decrypt_buffer(const uint8_t* input, const uint8_t* key, uint8_t *output)
|
||||
{
|
||||
printf("AES_ECB_encrypt not implemented\n");
|
||||
exit(-1);
|
||||
static aes_context ctx;
|
||||
if(key!=0)
|
||||
{
|
||||
aes_init( &ctx);
|
||||
aes_setkey_dec(&ctx,key,AES_KEYSIZE);
|
||||
}
|
||||
int ret=aes_crypt_ecb( &ctx, AES_DECRYPT, (const unsigned char*)input,(unsigned char*) output );
|
||||
assert(ret==0);
|
||||
return ;
|
||||
}
|
||||
|
||||
void AES_CBC_encrypt_buffer(uint8_t* output, uint8_t* input, uint32_t length, const uint8_t* key, const uint8_t* iv)
|
||||
|
||||
87
log.cpp
Executable file → Normal file
87
log.cpp
Executable file → Normal file
@ -1,62 +1,57 @@
|
||||
#include "log.h"
|
||||
#include "misc.h"
|
||||
|
||||
int log_level=log_info;
|
||||
int log_level = log_info;
|
||||
|
||||
int enable_log_position=0;
|
||||
int enable_log_color=1;
|
||||
int enable_log_position = 0;
|
||||
int enable_log_color = 1;
|
||||
|
||||
void log0(const char * file,const char * function,int line,int level,const char* str, ...) {
|
||||
void log0(const char* file, const char* function, int line, int level, const char* str, ...) {
|
||||
if (level > log_level) return;
|
||||
if (level > log_trace || level < 0) return;
|
||||
|
||||
if(level>log_level) return ;
|
||||
if(level>log_trace||level<0) return ;
|
||||
time_t timer;
|
||||
char buffer[100];
|
||||
struct tm* tm_info;
|
||||
|
||||
time(&timer);
|
||||
tm_info = localtime(&timer);
|
||||
|
||||
time_t timer;
|
||||
char buffer[100];
|
||||
struct tm* tm_info;
|
||||
if (enable_log_color)
|
||||
printf("%s", log_color[level]);
|
||||
|
||||
time(&timer);
|
||||
tm_info = localtime(&timer);
|
||||
strftime(buffer, 100, "%Y-%m-%d %H:%M:%S", tm_info);
|
||||
printf("[%s][%s]", buffer, log_text[level]);
|
||||
|
||||
if(enable_log_color)
|
||||
printf("%s",log_color[level]);
|
||||
if (enable_log_position) printf("[%s,func:%s,line:%d]", file, function, line);
|
||||
|
||||
strftime(buffer, 100, "%Y-%m-%d %H:%M:%S", tm_info);
|
||||
printf("[%s][%s]",buffer,log_text[level]);
|
||||
va_list vlist;
|
||||
va_start(vlist, str);
|
||||
vfprintf(stdout, str, vlist);
|
||||
va_end(vlist);
|
||||
if (enable_log_color)
|
||||
printf("%s", RESET);
|
||||
|
||||
if(enable_log_position)printf("[%s,func:%s,line:%d]",file,function,line);
|
||||
// printf("\n");
|
||||
// if(enable_log_color)
|
||||
// printf(log_color[level]);
|
||||
fflush(stdout);
|
||||
|
||||
va_list vlist;
|
||||
va_start(vlist, str);
|
||||
vfprintf(stdout, str, vlist);
|
||||
va_end(vlist);
|
||||
if(enable_log_color)
|
||||
printf("%s",RESET);
|
||||
|
||||
//printf("\n");
|
||||
//if(enable_log_color)
|
||||
//printf(log_color[level]);
|
||||
fflush(stdout);
|
||||
|
||||
if(log_level==log_fatal)
|
||||
{
|
||||
about_to_exit=1;
|
||||
}
|
||||
if (log_level == log_fatal) {
|
||||
about_to_exit = 1;
|
||||
}
|
||||
}
|
||||
|
||||
void log_bare(int level,const char* str, ...)
|
||||
{
|
||||
if(level>log_level) return ;
|
||||
if(level>log_trace||level<0) return ;
|
||||
if(enable_log_color)
|
||||
printf("%s",log_color[level]);
|
||||
va_list vlist;
|
||||
va_start(vlist, str);
|
||||
vfprintf(stdout, str, vlist);
|
||||
va_end(vlist);
|
||||
if(enable_log_color)
|
||||
printf("%s",RESET);
|
||||
fflush(stdout);
|
||||
|
||||
void log_bare(int level, const char* str, ...) {
|
||||
if (level > log_level) return;
|
||||
if (level > log_trace || level < 0) return;
|
||||
if (enable_log_color)
|
||||
printf("%s", log_color[level]);
|
||||
va_list vlist;
|
||||
va_start(vlist, str);
|
||||
vfprintf(stdout, str, vlist);
|
||||
va_end(vlist);
|
||||
if (enable_log_color)
|
||||
printf("%s", RESET);
|
||||
fflush(stdout);
|
||||
}
|
||||
|
||||
49
log.h
Executable file → Normal file
49
log.h
Executable file → Normal file
@ -2,53 +2,46 @@
|
||||
#ifndef UDP2RAW_LOG_MYLOG_H_
|
||||
#define UDP2RAW_LOG_MYLOG_H_
|
||||
|
||||
|
||||
#include "common.h"
|
||||
|
||||
|
||||
using namespace std;
|
||||
|
||||
|
||||
#define RED "\x1B[31m"
|
||||
#define GRN "\x1B[32m"
|
||||
#define YEL "\x1B[33m"
|
||||
#define BLU "\x1B[34m"
|
||||
#define MAG "\x1B[35m"
|
||||
#define CYN "\x1B[36m"
|
||||
#define WHT "\x1B[37m"
|
||||
#define RED "\x1B[31m"
|
||||
#define GRN "\x1B[32m"
|
||||
#define YEL "\x1B[33m"
|
||||
#define BLU "\x1B[34m"
|
||||
#define MAG "\x1B[35m"
|
||||
#define CYN "\x1B[36m"
|
||||
#define WHT "\x1B[37m"
|
||||
#define RESET "\x1B[0m"
|
||||
|
||||
const int log_never = 0;
|
||||
const int log_fatal = 1;
|
||||
const int log_error = 2;
|
||||
const int log_warn = 3;
|
||||
const int log_info = 4;
|
||||
const int log_debug = 5;
|
||||
const int log_trace = 6;
|
||||
const int log_end = 7;
|
||||
|
||||
const int log_never=0;
|
||||
const int log_fatal=1;
|
||||
const int log_error=2;
|
||||
const int log_warn=3;
|
||||
const int log_info=4;
|
||||
const int log_debug=5;
|
||||
const int log_trace=6;
|
||||
const int log_end=7;
|
||||
|
||||
const char log_text[][20]={"NEVER","FATAL","ERROR","WARN","INFO","DEBUG","TRACE",""};
|
||||
const char log_color[][20]={RED,RED,RED,YEL,GRN,MAG,""};
|
||||
const char log_text[][20] = {"NEVER", "FATAL", "ERROR", "WARN", "INFO", "DEBUG", "TRACE", ""};
|
||||
const char log_color[][20] = {RED, RED, RED, YEL, GRN, MAG, ""};
|
||||
|
||||
extern int log_level;
|
||||
extern int enable_log_position;
|
||||
extern int enable_log_color;
|
||||
|
||||
|
||||
#ifdef MY_DEBUG
|
||||
#define mylog(__first_argu__dummy_abcde__,...) printf(__VA_ARGS__)
|
||||
#define mylog(__first_argu__dummy_abcde__, ...) printf(__VA_ARGS__)
|
||||
|
||||
#else
|
||||
#define mylog(...) log0(__FILE__,__FUNCTION__,__LINE__,__VA_ARGS__)
|
||||
#define mylog(...) log0(__FILE__, __FUNCTION__, __LINE__, __VA_ARGS__)
|
||||
#endif
|
||||
|
||||
|
||||
//#define mylog(__first_argu__dummy_abcde__,...) {;}
|
||||
|
||||
void log0(const char * file,const char * function,int line,int level,const char* str, ...);
|
||||
|
||||
void log_bare(int level,const char* str, ...);
|
||||
void log0(const char* file, const char* function, int line, int level, const char* str, ...);
|
||||
|
||||
void log_bare(int level, const char* str, ...);
|
||||
|
||||
#endif
|
||||
|
||||
136
main.cpp
Executable file → Normal file
136
main.cpp
Executable file → Normal file
@ -7,96 +7,100 @@
|
||||
#include "encrypt.h"
|
||||
#include "fd_manager.h"
|
||||
|
||||
void sigpipe_cb(struct ev_loop *l, ev_signal *w, int revents)
|
||||
{
|
||||
mylog(log_info, "got sigpipe, ignored");
|
||||
void sigpipe_cb(struct ev_loop *l, ev_signal *w, int revents) {
|
||||
mylog(log_info, "got sigpipe, ignored");
|
||||
}
|
||||
|
||||
void sigterm_cb(struct ev_loop *l, ev_signal *w, int revents)
|
||||
{
|
||||
mylog(log_info, "got sigterm, exit");
|
||||
myexit(0);
|
||||
void sigterm_cb(struct ev_loop *l, ev_signal *w, int revents) {
|
||||
mylog(log_info, "got sigterm, exit");
|
||||
myexit(0);
|
||||
}
|
||||
|
||||
void sigint_cb(struct ev_loop *l, ev_signal *w, int revents)
|
||||
{
|
||||
mylog(log_info, "got sigint, exit");
|
||||
myexit(0);
|
||||
void sigint_cb(struct ev_loop *l, ev_signal *w, int revents) {
|
||||
mylog(log_info, "got sigint, exit");
|
||||
myexit(0);
|
||||
}
|
||||
|
||||
int client_event_loop();
|
||||
int server_event_loop();
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
assert(sizeof(unsigned short)==2);
|
||||
assert(sizeof(unsigned int)==4);
|
||||
assert(sizeof(unsigned long long)==8);
|
||||
int main(int argc, char *argv[]) {
|
||||
assert(sizeof(unsigned short) == 2);
|
||||
assert(sizeof(unsigned int) == 4);
|
||||
assert(sizeof(unsigned long long) == 8);
|
||||
|
||||
dup2(1, 2);//redirect stderr to stdout
|
||||
#ifdef UDP2RAW_MP
|
||||
init_ws();
|
||||
#endif
|
||||
|
||||
dup2(1, 2); // redirect stderr to stdout
|
||||
#if defined(__MINGW32__)
|
||||
enable_log_color=0;
|
||||
enable_log_color = 0;
|
||||
#endif
|
||||
|
||||
pre_process_arg(argc,argv);
|
||||
pre_process_arg(argc, argv);
|
||||
|
||||
if(program_mode==client_mode)
|
||||
{
|
||||
struct ev_loop* loop=ev_default_loop(0);
|
||||
ev_signal signal_watcher_sigpipe;
|
||||
ev_signal signal_watcher_sigterm;
|
||||
ev_signal signal_watcher_sigint;
|
||||
|
||||
if (program_mode == client_mode) {
|
||||
struct ev_loop *loop = ev_default_loop(0);
|
||||
#if !defined(__MINGW32__)
|
||||
ev_signal signal_watcher_sigpipe;
|
||||
ev_signal_init(&signal_watcher_sigpipe, sigpipe_cb, SIGPIPE);
|
||||
ev_signal_start(loop, &signal_watcher_sigpipe);
|
||||
ev_signal_init(&signal_watcher_sigpipe, sigpipe_cb, SIGPIPE);
|
||||
ev_signal_start(loop, &signal_watcher_sigpipe);
|
||||
#endif
|
||||
ev_signal_init(&signal_watcher_sigterm, sigterm_cb, SIGTERM);
|
||||
ev_signal_start(loop, &signal_watcher_sigterm);
|
||||
|
||||
ev_signal signal_watcher_sigterm;
|
||||
ev_signal_init(&signal_watcher_sigterm, sigterm_cb, SIGTERM);
|
||||
ev_signal_start(loop, &signal_watcher_sigterm);
|
||||
|
||||
ev_signal signal_watcher_sigint;
|
||||
ev_signal_init(&signal_watcher_sigint, sigint_cb, SIGINT);
|
||||
ev_signal_start(loop, &signal_watcher_sigint);
|
||||
}
|
||||
else
|
||||
{
|
||||
signal(SIGINT, signal_handler);
|
||||
signal(SIGHUP, signal_handler);
|
||||
signal(SIGKILL, signal_handler);
|
||||
signal(SIGTERM, signal_handler);
|
||||
signal(SIGQUIT, signal_handler);
|
||||
}
|
||||
ev_signal_init(&signal_watcher_sigint, sigint_cb, SIGINT);
|
||||
ev_signal_start(loop, &signal_watcher_sigint);
|
||||
} else {
|
||||
#ifdef UDP2RAW_LINUX
|
||||
signal(SIGINT, signal_handler);
|
||||
signal(SIGHUP, signal_handler);
|
||||
signal(SIGKILL, signal_handler);
|
||||
signal(SIGTERM, signal_handler);
|
||||
signal(SIGQUIT, signal_handler);
|
||||
#else
|
||||
mylog(log_fatal, "server mode not supported in multi-platform version\n");
|
||||
myexit(-1);
|
||||
#endif
|
||||
}
|
||||
#if !defined(__MINGW32__)
|
||||
if(geteuid() != 0)
|
||||
{
|
||||
mylog(log_warn,"root check failed, it seems like you are using a non-root account. we can try to continue, but it may fail. If you want to run udp2raw as non-root, you have to add iptables rule manually, and grant udp2raw CAP_NET_RAW capability, check README.md in repo for more info.\n");
|
||||
}
|
||||
else
|
||||
{
|
||||
mylog(log_warn,"you can run udp2raw with non-root account for better security. check README.md in repo for more info.\n");
|
||||
}
|
||||
if (geteuid() != 0) {
|
||||
mylog(log_warn, "root check failed, it seems like you are using a non-root account. we can try to continue, but it may fail. If you want to run udp2raw as non-root, you have to add iptables rule manually, and grant udp2raw CAP_NET_RAW capability, check README.md in repo for more info.\n");
|
||||
} else {
|
||||
mylog(log_warn, "you can run udp2raw with non-root account for better security. check README.md in repo for more info.\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
mylog(log_info,"remote_ip=[%s], make sure this is a vaild IP address\n",remote_addr.get_ip());
|
||||
mylog(log_info, "remote_ip=[%s], make sure this is a vaild IP address\n", remote_addr.get_ip());
|
||||
|
||||
//init_random_number_fd();
|
||||
srand(get_true_random_number_nz());
|
||||
const_id=get_true_random_number_nz();
|
||||
// init_random_number_fd();
|
||||
srand(get_true_random_number_nz());
|
||||
const_id = get_true_random_number_nz();
|
||||
|
||||
mylog(log_info,"const_id:%x\n",const_id);
|
||||
mylog(log_info, "const_id:%x\n", const_id);
|
||||
|
||||
my_init_keys(key_string,program_mode==client_mode?1:0);
|
||||
my_init_keys(key_string, program_mode == client_mode ? 1 : 0);
|
||||
|
||||
iptables_rule();
|
||||
init_raw_socket();
|
||||
iptables_rule();
|
||||
|
||||
if(program_mode==client_mode)
|
||||
{
|
||||
client_event_loop();
|
||||
}
|
||||
else
|
||||
{
|
||||
server_event_loop();
|
||||
}
|
||||
#ifdef UDP2RAW_LINUX
|
||||
init_raw_socket();
|
||||
#endif
|
||||
|
||||
return 0;
|
||||
if (program_mode == client_mode) {
|
||||
client_event_loop();
|
||||
} else {
|
||||
#ifdef UDP2RAW_LINUX
|
||||
server_event_loop();
|
||||
#else
|
||||
mylog(log_fatal, "server mode not supported in multi-platform version\n");
|
||||
myexit(-1);
|
||||
#endif
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
145
makefile
145
makefile
@ -1,91 +1,134 @@
|
||||
cc_cross=/home/wangyu/Desktop/arm-2014.05/bin/arm-none-linux-gnueabi-g++
|
||||
cc_local=g++
|
||||
#cc_local=/opt/cross/x86_64-linux-musl/bin/x86_64-linux-musl-g++
|
||||
#cc_mips34kc=/toolchains/OpenWrt-SDK-ar71xx-for-linux-x86_64-gcc-4.8-linaro_uClibc-0.9.33.2/staging_dir/toolchain-mips_34kc_gcc-4.8-linaro_uClibc-0.9.33.2/bin/mips-openwrt-linux-g++
|
||||
cc_mips24kc_be=/toolchains/lede-sdk-17.01.2-ar71xx-generic_gcc-5.4.0_musl-1.1.16.Linux-x86_64/staging_dir/toolchain-mips_24kc_gcc-5.4.0_musl-1.1.16/bin/mips-openwrt-linux-musl-g++
|
||||
cc_mips24kc_le=/toolchains/lede-sdk-17.01.2-ramips-mt7621_gcc-5.4.0_musl-1.1.16.Linux-x86_64/staging_dir/toolchain-mipsel_24kc_gcc-5.4.0_musl-1.1.16/bin/mipsel-openwrt-linux-musl-g++
|
||||
#cc_arm= /toolchains/gcc-linaro-4.9.4-2017.01-x86_64_arm-linux-gnueabi/bin/arm-linux-gnueabi-g++ -march=armv6 -marm
|
||||
cc_arm= /toolchains/arm-2014.05/bin/arm-none-linux-gnueabi-g++
|
||||
#cc_arm=/toolchains/lede-sdk-17.01.2-brcm2708-bcm2708_gcc-5.4.0_musl-1.1.16_eabi.Linux-x86_64/staging_dir/toolchain-arm_arm1176jzf-s+vfp_gcc-5.4.0_musl-1.1.16_eabi/bin/arm-openwrt-linux-muslgnueabi-g++
|
||||
cc_arm= /toolchains/lede-sdk-17.01.2-bcm53xx_gcc-5.4.0_musl-1.1.16_eabi.Linux-x86_64/staging_dir/toolchain-arm_cortex-a9_gcc-5.4.0_musl-1.1.16_eabi/bin/arm-openwrt-linux-c++
|
||||
cc_mingw_cross=i686-w64-mingw32-g++-posix
|
||||
cc_mac_cross=o64-clang++ -stdlib=libc++
|
||||
cc_x86=/toolchains/lede-sdk-17.01.2-x86-generic_gcc-5.4.0_musl-1.1.16.Linux-x86_64/staging_dir/toolchain-i386_pentium4_gcc-5.4.0_musl-1.1.16/bin/i486-openwrt-linux-c++
|
||||
cc_amd64=/toolchains/lede-sdk-17.01.2-x86-64_gcc-5.4.0_musl-1.1.16.Linux-x86_64/staging_dir/toolchain-x86_64_gcc-5.4.0_musl-1.1.16/bin/x86_64-openwrt-linux-c++
|
||||
#cc_bcm2708=/home/wangyu/raspberry/tools/arm-bcm2708/gcc-linaro-arm-linux-gnueabihf-raspbian/bin/arm-linux-gnueabihf-g++
|
||||
FLAGS= -std=c++11 -Wall -Wextra -Wno-unused-variable -Wno-unused-parameter -Wno-missing-field-initializers ${OPT}
|
||||
|
||||
COMMON=main.cpp lib/md5.cpp lib/pbkdf2-sha1.cpp lib/pbkdf2-sha256.cpp encrypt.cpp log.cpp network.cpp common.cpp connection.cpp misc.cpp fd_manager.cpp client.cpp server.cpp -lpthread my_ev.cpp -isystem libev
|
||||
SOURCES= $(COMMON) lib/aes_faster_c/aes.cpp lib/aes_faster_c/wrapper.cpp
|
||||
SOURCES_TINY_AES= $(COMMON) lib/aes.c
|
||||
SOURCES_AES_ACC=$(COMMON) $(wildcard lib/aes_acc/aes*.c)
|
||||
|
||||
FLAGS= -std=c++11 -Wall -Wextra -Wno-unused-variable -Wno-unused-parameter -Wno-missing-field-initializers ${OPT}
|
||||
|
||||
COMMON=main.cpp lib/md5.cpp lib/pbkdf2-sha1.cpp lib/pbkdf2-sha256.cpp encrypt.cpp log.cpp network.cpp common.cpp connection.cpp misc.cpp fd_manager.cpp client.cpp server.cpp -lpthread
|
||||
|
||||
SOURCES0= $(COMMON) lib/aes_faster_c/aes.cpp lib/aes_faster_c/wrapper.cpp
|
||||
SOURCES= ${SOURCES0} my_ev.cpp -isystem libev
|
||||
SOURCES_AES_ACC= $(COMMON) $(wildcard lib/aes_acc/aes*.c) my_ev.cpp -isystem libev
|
||||
PCAP="-lpcap"
|
||||
MP="-DUDP2RAW_MP"
|
||||
|
||||
|
||||
NAME=udp2raw
|
||||
TARGETS=amd64 arm amd64_hw_aes arm_asm_aes mips24kc_be mips24kc_be_asm_aes x86 x86_asm_aes mips24kc_le mips24kc_le_asm_aes
|
||||
TAR=${NAME}_binaries.tar.gz `echo ${TARGETS}|sed -r 's/([^ ]+)/udp2raw_\1/g'` version.txt
|
||||
|
||||
TARGETS=amd64 arm amd64_hw_aes arm_asm_aes mips24kc_be mips24kc_be_asm_aes x86 x86_asm_aes mips24kc_le mips24kc_le_asm_aes
|
||||
|
||||
TAR=${NAME}_binaries.tar.gz `echo ${TARGETS}|sed -r 's/([^ ]+)/${NAME}_\1/g'` version.txt
|
||||
|
||||
TARGETS_MP= mingw_cross mingw_cross_wepoll mac_cross
|
||||
|
||||
export STAGING_DIR=/tmp/ #just for supress warning of staging_dir not define
|
||||
|
||||
# targets for nativei (non-cross) compile
|
||||
all:git_version
|
||||
rm -f ${NAME}
|
||||
${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -ggdb -static -O3
|
||||
${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -ggdb -static -O2
|
||||
|
||||
#dynamic link
|
||||
dynamic: git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -O2
|
||||
|
||||
#targes for general cross compile
|
||||
|
||||
cross:git_version
|
||||
${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -O2
|
||||
|
||||
cross2:git_version
|
||||
${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -static -lgcc_eh -O2
|
||||
|
||||
cross3:git_version
|
||||
${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -static -O2
|
||||
|
||||
#targets only for debug purpose
|
||||
fast: git_version
|
||||
rm -f ${NAME}
|
||||
${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -ggdb
|
||||
debug: git_version
|
||||
rm -f ${NAME}
|
||||
${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -Wformat-nonliteral -D MY_DEBUG
|
||||
${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -Wformat-nonliteral -D MY_DEBUG -ggdb
|
||||
debug2: git_version
|
||||
rm -f ${NAME}
|
||||
${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -Wformat-nonliteral -ggdb
|
||||
${cc_local} -o ${NAME} -I. ${SOURCES} ${FLAGS} -lrt -Wformat-nonliteral -ggdb -fsanitize=address
|
||||
|
||||
dynamic: git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -O3
|
||||
#targets only for 'make release'
|
||||
|
||||
mips24kc_be: git_version
|
||||
${cc_mips24kc_be} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -lgcc_eh -static -O3
|
||||
${cc_mips24kc_be} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -lgcc_eh -static -O2
|
||||
mips24kc_be_asm_aes: git_version
|
||||
${cc_mips24kc_be} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -lgcc_eh -static -O3 lib/aes_acc/asm/mips_be.S
|
||||
|
||||
${cc_mips24kc_be} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -lgcc_eh -static -O2 lib/aes_acc/asm/mips_be.S
|
||||
mips24kc_le: git_version
|
||||
${cc_mips24kc_le} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -lgcc_eh -static -O3
|
||||
${cc_mips24kc_le} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -lgcc_eh -static -O2
|
||||
mips24kc_le_asm_aes: git_version
|
||||
${cc_mips24kc_le} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -lgcc_eh -static -O3 lib/aes_acc/asm/mips.S
|
||||
|
||||
#bcm2708:
|
||||
# ${cc_bcm2708} -o ${NAME}_bcm2708 -I. ${SOURCES} ${FLAGS} -lrt -static -O3
|
||||
${cc_mips24kc_le} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -lgcc_eh -static -O2 lib/aes_acc/asm/mips.S
|
||||
amd64:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O3
|
||||
|
||||
amd64_perf:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O0 -fno-omit-frame-pointer -g
|
||||
|
||||
${cc_amd64} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O2 -lgcc_eh -ggdb
|
||||
amd64_hw_aes:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -static -O3 lib/aes_acc/asm/x64.S
|
||||
${cc_amd64} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -static -O2 lib/aes_acc/asm/x64.S -lgcc_eh -ggdb
|
||||
x86:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O3 -m32
|
||||
${cc_x86} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O2 -lgcc_eh -ggdb
|
||||
x86_asm_aes:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -static -O3 -m32 lib/aes_acc/asm/x86.S
|
||||
${cc_x86} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -static -O2 lib/aes_acc/asm/x86.S -lgcc_eh -ggdb
|
||||
arm:git_version
|
||||
${cc_arm} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O3
|
||||
|
||||
arm_perf:git_version
|
||||
${cc_arm} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -mapcs-frame -fno-omit-frame-pointer -g -O0 -lgcc_eh
|
||||
|
||||
${cc_arm} -o ${NAME}_$@ -I. ${SOURCES} ${FLAGS} -lrt -static -O2 -lgcc_eh
|
||||
arm_asm_aes:git_version
|
||||
${cc_arm} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -static -O3 lib/aes_acc/asm/arm.S
|
||||
${cc_arm} -o ${NAME}_$@ -I. ${SOURCES_AES_ACC} ${FLAGS} -lrt -static -O2 lib/aes_acc/asm/arm.S -lgcc_eh
|
||||
|
||||
cross:git_version
|
||||
${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -O3
|
||||
|
||||
cross2:git_version
|
||||
${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -static -lgcc_eh -O3
|
||||
|
||||
cross3:git_version
|
||||
${cc_cross} -o ${NAME}_cross -I. ${SOURCES} ${FLAGS} -lrt -static -O3
|
||||
|
||||
release: ${TARGETS}
|
||||
release: ${TARGETS}
|
||||
cp git_version.h version.txt
|
||||
tar -zcvf ${TAR}
|
||||
|
||||
#targets for multi-platform version (native compile)
|
||||
cygwin:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} pcap_wrapper.cpp ${FLAGS} -lrt -ggdb -static -O2 -D_GNU_SOURCE ${MP}
|
||||
|
||||
mingw:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} pcap_wrapper.cpp ${FLAGS} -ggdb -static -O2 -lws2_32 ${MP}
|
||||
|
||||
mingw_wepoll:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES0} pcap_wrapper.cpp ${FLAGS} -ggdb -static -O2 -DNO_LIBEV_EMBED -D_WIN32 -lev -lws2_32 ${MP}
|
||||
|
||||
linux:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${PCAP} ${FLAGS} -lrt -ggdb -static -O2 ${MP}
|
||||
|
||||
freebsd:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${PCAP} ${FLAGS} -lrt -ggdb -static -libverbs -O2 ${MP}
|
||||
|
||||
mac:git_version
|
||||
${cc_local} -o ${NAME}_$@ -I. ${SOURCES} ${PCAP} ${FLAGS} -ggdb -O2 ${MP}
|
||||
|
||||
#targets for multi-platform version (cross compile)
|
||||
|
||||
mingw_cross:git_version
|
||||
${cc_mingw_cross} -o ${NAME}_mp.exe -I. ${SOURCES} pcap_wrapper.cpp ${FLAGS} -ggdb -static -O2 -lws2_32 ${MP}
|
||||
|
||||
mingw_cross_wepoll:git_version
|
||||
${cc_mingw_cross} -o ${NAME}_mp_wepoll.exe -I. ${SOURCES0} pcap_wrapper.cpp ${FLAGS} -ggdb -static -O2 -DNO_LIBEV_EMBED -D_WIN32 -lev -lws2_32 ${MP}
|
||||
|
||||
mac_cross:git_version
|
||||
${cc_mac_cross} -o ${NAME}_mp_mac -I. ${SOURCES} ${PCAP} ${FLAGS} -ggdb -O2 ${MP}
|
||||
|
||||
release_mp:${TARGETS_MP}
|
||||
cp git_version.h version.txt
|
||||
tar -zcvf ${NAME}_mp_binaries.tar.gz ${NAME}_mp.exe ${NAME}_mp_wepoll.exe ${NAME}_mp_mac version.txt
|
||||
|
||||
|
||||
clean:
|
||||
rm -f ${TAR}
|
||||
rm -f udp2raw udp2raw_cross udp2raw_cmake udp2raw_dynamic
|
||||
rm -f ${NAME} ${NAME}_cross ${NAME}.exe ${NAME}_wepoll.exe ${NAME}_mac
|
||||
rm -f ${NAME}_mp_binaries.tar.gz ${NAME}_mp.exe ${NAME}_mp_wepoll.exe ${NAME}_mp_mac
|
||||
rm -f git_version.h
|
||||
|
||||
git_version:
|
||||
echo "const char *gitversion = \"$(shell git rev-parse HEAD)\";" > git_version.h
|
||||
|
||||
|
||||
140
misc.h
140
misc.h
@ -8,7 +8,6 @@
|
||||
#ifndef MISC_H_
|
||||
#define MISC_H_
|
||||
|
||||
|
||||
#include "common.h"
|
||||
#include "log.h"
|
||||
#include "network.h"
|
||||
@ -26,128 +25,131 @@ extern int enable_dns_resolve;
|
||||
|
||||
extern int ttl_value;
|
||||
|
||||
const u32_t max_handshake_conn_num = 10000;
|
||||
const u32_t max_ready_conn_num = 1000;
|
||||
const u32_t anti_replay_window_size = 4000;
|
||||
const int max_conv_num = 10000;
|
||||
|
||||
const u32_t max_handshake_conn_num=10000;
|
||||
const u32_t max_ready_conn_num=1000;
|
||||
const u32_t anti_replay_window_size=4000;
|
||||
const int max_conv_num=10000;
|
||||
const u32_t client_handshake_timeout = 5000; // unit ms
|
||||
const u32_t client_retry_interval = 1000; // ms
|
||||
|
||||
const u32_t client_handshake_timeout=5000;//unit ms
|
||||
const u32_t client_retry_interval=1000;//ms
|
||||
const u32_t server_handshake_timeout = client_handshake_timeout + 5000; // this should be longer than clients. client retry initially ,server retry passtively
|
||||
|
||||
const u32_t server_handshake_timeout=client_handshake_timeout+5000;// this should be longer than clients. client retry initially ,server retry passtively
|
||||
const int conv_clear_ratio = 30; // conv grabage collecter check 1/30 of all conv one time
|
||||
const int conn_clear_ratio = 50;
|
||||
const int conv_clear_min = 1;
|
||||
const int conn_clear_min = 1;
|
||||
|
||||
const int conv_clear_ratio=30; //conv grabage collecter check 1/30 of all conv one time
|
||||
const int conn_clear_ratio=50;
|
||||
const int conv_clear_min=1;
|
||||
const int conn_clear_min=1;
|
||||
const u32_t conv_clear_interval = 1000; // ms
|
||||
const u32_t conn_clear_interval = 1000; // ms
|
||||
|
||||
const u32_t conv_clear_interval=1000;//ms
|
||||
const u32_t conn_clear_interval=1000;//ms
|
||||
const i32_t max_fail_time = 0; // disable
|
||||
|
||||
const u32_t heartbeat_interval = 600; // ms
|
||||
|
||||
const i32_t max_fail_time=0;//disable
|
||||
const u32_t timer_interval = 400; // ms. this should be smaller than heartbeat_interval and retry interval;
|
||||
|
||||
const u32_t heartbeat_interval=600;//ms
|
||||
const uint32_t conv_timeout = 180000; // ms. 120 second
|
||||
// const u32_t conv_timeout=30000; //for test
|
||||
|
||||
const u32_t timer_interval=400;//ms. this should be smaller than heartbeat_interval and retry interval;
|
||||
const u32_t client_conn_timeout = 10000; // ms.
|
||||
const u32_t client_conn_uplink_timeout = client_conn_timeout + 2000; // ms
|
||||
|
||||
const uint32_t conv_timeout=180000; //ms. 120 second
|
||||
//const u32_t conv_timeout=30000; //for test
|
||||
const uint32_t server_conn_timeout = conv_timeout + 60000; // ms. this should be 60s+ longer than conv_timeout,so that conv_manager can destruct convs gradually,to avoid latency glicth
|
||||
// const u32_t server_conn_timeout=conv_timeout+10000;//for test
|
||||
|
||||
const u32_t client_conn_timeout=10000;//ms.
|
||||
const u32_t client_conn_uplink_timeout=client_conn_timeout+2000;//ms
|
||||
const u32_t iptables_rule_keep_interval = 20; // unit: second;
|
||||
|
||||
const uint32_t server_conn_timeout=conv_timeout+60000;//ms. this should be 60s+ longer than conv_timeout,so that conv_manager can destruct convs gradually,to avoid latency glicth
|
||||
//const u32_t server_conn_timeout=conv_timeout+10000;//for test
|
||||
enum server_current_state_t { server_idle = 0,
|
||||
server_handshake1,
|
||||
server_ready }; // server state machine
|
||||
enum client_current_state_t { client_idle = 0,
|
||||
client_tcp_handshake,
|
||||
client_handshake1,
|
||||
client_handshake2,
|
||||
client_ready,
|
||||
client_tcp_handshake_dummy }; // client state machine
|
||||
|
||||
const u32_t iptables_rule_keep_interval=20;//unit: second;
|
||||
enum raw_mode_t { mode_faketcp = 0,
|
||||
mode_udp,
|
||||
mode_icmp,
|
||||
mode_end };
|
||||
enum program_mode_t { unset_mode = 0,
|
||||
client_mode,
|
||||
server_mode };
|
||||
|
||||
enum server_current_state_t {server_idle=0,server_handshake1,server_ready}; //server state machine
|
||||
enum client_current_state_t {client_idle=0,client_tcp_handshake,client_handshake1,client_handshake2,client_ready,client_tcp_handshake_dummy};//client state machine
|
||||
|
||||
enum raw_mode_t{mode_faketcp=0,mode_udp,mode_icmp,mode_end};
|
||||
enum program_mode_t {unset_mode=0,client_mode,server_mode};
|
||||
|
||||
union current_state_t
|
||||
{
|
||||
server_current_state_t server_current_state;
|
||||
client_current_state_t client_current_state;
|
||||
union current_state_t {
|
||||
server_current_state_t server_current_state;
|
||||
client_current_state_t client_current_state;
|
||||
};
|
||||
|
||||
//extern char remote_address[max_address_len];
|
||||
//extern char local_ip[100], remote_ip[100],source_ip[100];//local_ip is for -l option,remote_ip for -r option,source for --source-ip
|
||||
//extern u32_t local_ip_uint32,remote_ip_uint32,source_ip_uint32;//convert from last line.
|
||||
//extern int local_port , remote_port,source_port;//similiar to local_ip remote_ip,buf for port.source_port=0 indicates --source-port is not enabled
|
||||
// extern char remote_address[max_address_len];
|
||||
// extern char local_ip[100], remote_ip[100],source_ip[100];//local_ip is for -l option,remote_ip for -r option,source for --source-ip
|
||||
// extern u32_t local_ip_uint32,remote_ip_uint32,source_ip_uint32;//convert from last line.
|
||||
// extern int local_port , remote_port,source_port;//similiar to local_ip remote_ip,buf for port.source_port=0 indicates --source-port is not enabled
|
||||
|
||||
extern address_t local_addr,remote_addr,source_addr;
|
||||
extern address_t local_addr, remote_addr, source_addr;
|
||||
|
||||
extern my_ip_t bind_addr;
|
||||
|
||||
extern int bind_addr_used;
|
||||
extern int force_source_ip; //if --source-ip is enabled
|
||||
extern int force_source_ip; // if --source-ip is enabled
|
||||
extern int force_source_port;
|
||||
extern int source_port;
|
||||
|
||||
extern my_id_t const_id;//an id used for connection recovery,its generated randomly,it never change since its generated
|
||||
extern my_id_t const_id; // an id used for connection recovery,its generated randomly,it never change since its generated
|
||||
|
||||
extern int udp_fd; //for client only. client use this fd to listen and handle udp connection
|
||||
extern int bind_fd; //bind only,never send or recv. its just a dummy fd for bind,so that other program wont occupy the same port
|
||||
extern int epollfd; //fd for epoll
|
||||
extern int timer_fd; //the general timer fd for client and server.for server this is not the only timer find,every connection has a timer fd.
|
||||
extern int fail_time_counter;//determine if the max_fail_time is reached
|
||||
extern int epoll_trigger_counter;//for debug only
|
||||
extern int debug_flag;//for debug only
|
||||
extern int udp_fd; // for client only. client use this fd to listen and handle udp connection
|
||||
extern int bind_fd; // bind only,never send or recv. its just a dummy fd for bind,so that other program wont occupy the same port
|
||||
extern int epollfd; // fd for epoll
|
||||
extern int timer_fd; // the general timer fd for client and server.for server this is not the only timer find,every connection has a timer fd.
|
||||
extern int fail_time_counter; // determine if the max_fail_time is reached
|
||||
extern int epoll_trigger_counter; // for debug only
|
||||
extern int debug_flag; // for debug only
|
||||
|
||||
|
||||
extern int simple_rule; //deprecated.
|
||||
extern int keep_rule; //whether to monitor the iptables rule periodly,re-add if losted
|
||||
extern int auto_add_iptables_rule;//if -a is set
|
||||
extern int generate_iptables_rule;//if -g is set
|
||||
extern int generate_iptables_rule_add;// if --gen-add is set
|
||||
extern int simple_rule; // deprecated.
|
||||
extern int keep_rule; // whether to monitor the iptables rule periodly,re-add if losted
|
||||
extern int auto_add_iptables_rule; // if -a is set
|
||||
extern int generate_iptables_rule; // if -g is set
|
||||
extern int generate_iptables_rule_add; // if --gen-add is set
|
||||
extern int retry_on_error;
|
||||
const int retry_on_error_interval=10;
|
||||
const int retry_on_error_interval = 10;
|
||||
|
||||
extern int debug_resend; // debug only
|
||||
extern int debug_resend; // debug only
|
||||
|
||||
extern char key_string[1000];// -k option
|
||||
extern char key_string[1000]; // -k option
|
||||
extern char fifo_file[1000];
|
||||
|
||||
|
||||
extern raw_mode_t raw_mode;
|
||||
extern u32_t raw_ip_version;
|
||||
|
||||
extern program_mode_t program_mode;
|
||||
extern unordered_map<int, const char*> raw_mode_tostring ;
|
||||
extern unordered_map<int, const char *> raw_mode_tostring;
|
||||
|
||||
extern int about_to_exit;
|
||||
|
||||
extern int socket_buf_size;
|
||||
|
||||
|
||||
extern pthread_t keep_thread;
|
||||
extern int keep_thread_running;
|
||||
|
||||
|
||||
int process_lower_level_arg();
|
||||
void print_help();
|
||||
void iptables_rule();
|
||||
void pre_process_arg(int argc, char *argv[]);//mainly for load conf file;
|
||||
void pre_process_arg(int argc, char *argv[]); // mainly for load conf file;
|
||||
int unit_test();
|
||||
int set_timer(int epollfd,int &timer_fd);
|
||||
int set_timer_server(int epollfd,int &timer_fd,fd64_t &fd64);
|
||||
int set_timer(int epollfd, int &timer_fd);
|
||||
int set_timer_server(int epollfd, int &timer_fd, fd64_t &fd64);
|
||||
int handle_lower_level(raw_info_t &raw_info);
|
||||
|
||||
int add_iptables_rule(const char *);
|
||||
|
||||
int clear_iptables_rule();
|
||||
|
||||
int iptables_gen_add(const char * s,u32_t const_id);
|
||||
int iptables_rule_init(const char * s,u32_t const_id,int keep);
|
||||
int iptables_gen_add(const char *s, u32_t const_id);
|
||||
int iptables_rule_init(const char *s, u32_t const_id, int keep);
|
||||
int keep_iptables_rule();
|
||||
|
||||
|
||||
|
||||
void signal_handler(int sig);
|
||||
void signal_handler(int sig);
|
||||
|
||||
#endif /* MISC_H_ */
|
||||
|
||||
1
my_ev.h
1
my_ev.h
@ -2,4 +2,3 @@
|
||||
|
||||
#include "my_ev_common.h"
|
||||
#include "ev.h"
|
||||
|
||||
|
||||
@ -1,6 +1,8 @@
|
||||
|
||||
#define EV_STANDALONE 1
|
||||
#define EV_COMMON void *data; unsigned long long u64;
|
||||
#define EV_COMMON \
|
||||
void *data; \
|
||||
unsigned long long u64;
|
||||
#define EV_COMPAT3 0
|
||||
|
||||
//#include <wepoll.h>
|
||||
@ -8,11 +10,10 @@
|
||||
//#define EV_USE_SELECT 1
|
||||
//#define EV_SELECT_IS_WINSOCKET 1
|
||||
|
||||
# define EV_FD_TO_WIN32_HANDLE(fd) (fd)
|
||||
# define EV_WIN32_HANDLE_TO_FD(handle) (handle)
|
||||
# define EV_WIN32_CLOSE_FD(fd) closesocket (fd)
|
||||
# define FD_SETSIZE 4096
|
||||
#define EV_FD_TO_WIN32_HANDLE(fd) (fd)
|
||||
#define EV_WIN32_HANDLE_TO_FD(handle) (handle)
|
||||
#define EV_WIN32_CLOSE_FD(fd) closesocket(fd)
|
||||
#define FD_SETSIZE 4096
|
||||
|
||||
#endif
|
||||
//#define EV_VERIFY 2
|
||||
|
||||
|
||||
3958
network.cpp
3958
network.cpp
File diff suppressed because it is too large
Load Diff
342
network.h
342
network.h
@ -14,7 +14,7 @@ extern int use_tcp_dummy_socket;
|
||||
extern int seq_mode;
|
||||
extern int max_seq_mode;
|
||||
extern int filter_port;
|
||||
//extern u32_t bind_address_uint32;
|
||||
// extern u32_t bind_address_uint32;
|
||||
extern int disable_bpf_filter;
|
||||
|
||||
extern int lower_level;
|
||||
@ -27,19 +27,42 @@ extern int random_drop;
|
||||
|
||||
extern int ifindex;
|
||||
|
||||
extern char g_packet_buf[buf_len];
|
||||
extern char g_packet_buf[huge_buf_len];
|
||||
extern int g_packet_buf_len;
|
||||
extern int g_packet_buf_cnt;
|
||||
#ifdef UDP2RAW_MP
|
||||
extern queue_t my_queue;
|
||||
|
||||
extern ev_async async_watcher;
|
||||
extern struct ev_loop *g_default_loop;
|
||||
|
||||
struct my_iphdr
|
||||
{
|
||||
extern pthread_mutex_t queue_mutex;
|
||||
extern int use_pcap_mutex;
|
||||
|
||||
extern int pcap_cnt;
|
||||
|
||||
extern int pcap_link_header_len;
|
||||
|
||||
extern int send_with_pcap;
|
||||
extern int pcap_header_captured;
|
||||
extern int pcap_header_buf[buf_len];
|
||||
|
||||
struct icmphdr {
|
||||
uint8_t type;
|
||||
uint8_t code;
|
||||
uint16_t check_sum;
|
||||
uint16_t id;
|
||||
uint16_t seq;
|
||||
};
|
||||
#endif
|
||||
|
||||
struct my_iphdr {
|
||||
#ifdef UDP2RAW_LITTLE_ENDIAN
|
||||
unsigned char ihl:4;
|
||||
unsigned char version:4;
|
||||
unsigned char ihl : 4;
|
||||
unsigned char version : 4;
|
||||
#else
|
||||
unsigned char version:4;
|
||||
unsigned char ihl:4;
|
||||
unsigned char version : 4;
|
||||
unsigned char ihl : 4;
|
||||
#endif
|
||||
u_int8_t tos;
|
||||
u_int16_t tot_len;
|
||||
@ -51,105 +74,98 @@ struct my_iphdr
|
||||
u_int32_t saddr;
|
||||
u_int32_t daddr;
|
||||
/*The options start here. */
|
||||
};
|
||||
|
||||
|
||||
struct my_udphdr
|
||||
{
|
||||
/*__extension__*/ union
|
||||
{
|
||||
struct
|
||||
{
|
||||
u_int16_t uh_sport; /* source port */
|
||||
u_int16_t uh_dport; /* destination port */
|
||||
u_int16_t uh_ulen; /* udp length */
|
||||
u_int16_t uh_sum; /* udp checksum */
|
||||
};
|
||||
struct
|
||||
{
|
||||
u_int16_t source;
|
||||
u_int16_t dest;
|
||||
u_int16_t len;
|
||||
u_int16_t check;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
|
||||
struct my_tcphdr
|
||||
{
|
||||
/*__extension__*/ union
|
||||
{
|
||||
struct
|
||||
{
|
||||
u_int16_t th_sport; /* source port */
|
||||
u_int16_t th_dport; /* destination port */
|
||||
u_int32_t th_seq; /* sequence number */
|
||||
u_int32_t th_ack; /* acknowledgement number */
|
||||
# ifdef UDP2RAW_LITTLE_ENDIAN
|
||||
u_int8_t th_x2:4; /* (unused) */
|
||||
u_int8_t tc_off:4; /* data offset */
|
||||
# else
|
||||
u_int8_t th_off:4; /* data offset */
|
||||
u_int8_t th_x2:4; /* (unused) */
|
||||
# endif
|
||||
u_int8_t th_flags;
|
||||
# define TH_FIN 0x01
|
||||
# define TH_SYN 0x02
|
||||
# define TH_RST 0x04
|
||||
# define TH_PUSH 0x08
|
||||
# define TH_ACK 0x10
|
||||
# define TH_URG 0x20
|
||||
u_int16_t th_win; /* window */
|
||||
u_int16_t th_sum; /* checksum */
|
||||
u_int16_t th_urp; /* urgent pointer */
|
||||
};
|
||||
struct
|
||||
{
|
||||
u_int16_t source;
|
||||
u_int16_t dest;
|
||||
u_int32_t seq;
|
||||
u_int32_t ack_seq;
|
||||
# ifdef UDP2RAW_LITTLE_ENDIAN
|
||||
u_int16_t res1:4;
|
||||
u_int16_t doff:4;
|
||||
u_int16_t fin:1;
|
||||
u_int16_t syn:1;
|
||||
u_int16_t rst:1;
|
||||
u_int16_t psh:1;
|
||||
u_int16_t ack:1;
|
||||
u_int16_t urg:1;
|
||||
u_int16_t res2:2;
|
||||
# else
|
||||
u_int16_t doff:4;
|
||||
u_int16_t res1:4;
|
||||
u_int16_t res2:2;
|
||||
u_int16_t urg:1;
|
||||
u_int16_t ack:1;
|
||||
u_int16_t psh:1;
|
||||
u_int16_t rst:1;
|
||||
u_int16_t syn:1;
|
||||
u_int16_t fin:1;
|
||||
# endif
|
||||
u_int16_t window;
|
||||
u_int16_t check;
|
||||
u_int16_t urg_ptr;
|
||||
};
|
||||
struct my_udphdr {
|
||||
/*__extension__*/ union {
|
||||
struct
|
||||
{
|
||||
u_int16_t uh_sport; /* source port */
|
||||
u_int16_t uh_dport; /* destination port */
|
||||
u_int16_t uh_ulen; /* udp length */
|
||||
u_int16_t uh_sum; /* udp checksum */
|
||||
};
|
||||
struct
|
||||
{
|
||||
u_int16_t source;
|
||||
u_int16_t dest;
|
||||
u_int16_t len;
|
||||
u_int16_t check;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
struct my_ip6hdr
|
||||
{
|
||||
# ifdef UDP2RAW_LITTLE_ENDIAN
|
||||
uint8_t traffic_class_high:4;
|
||||
uint8_t version:4;
|
||||
uint8_t flow_label_high:4;
|
||||
uint8_t traffic_class_low:4;
|
||||
struct my_tcphdr {
|
||||
/*__extension__*/ union {
|
||||
struct
|
||||
{
|
||||
u_int16_t th_sport; /* source port */
|
||||
u_int16_t th_dport; /* destination port */
|
||||
u_int32_t th_seq; /* sequence number */
|
||||
u_int32_t th_ack; /* acknowledgement number */
|
||||
#ifdef UDP2RAW_LITTLE_ENDIAN
|
||||
u_int8_t th_x2 : 4; /* (unused) */
|
||||
u_int8_t tc_off : 4; /* data offset */
|
||||
#else
|
||||
uint8_t version:4;
|
||||
uint8_t traffic_class_high:4;
|
||||
uint8_t traffic_class_low:4;
|
||||
uint8_t flow_label_high:4;
|
||||
u_int8_t th_off : 4; /* data offset */
|
||||
u_int8_t th_x2 : 4; /* (unused) */
|
||||
#endif
|
||||
u_int8_t th_flags;
|
||||
#define TH_FIN 0x01
|
||||
#define TH_SYN 0x02
|
||||
#define TH_RST 0x04
|
||||
#define TH_PUSH 0x08
|
||||
#define TH_ACK 0x10
|
||||
#define TH_URG 0x20
|
||||
u_int16_t th_win; /* window */
|
||||
u_int16_t th_sum; /* checksum */
|
||||
u_int16_t th_urp; /* urgent pointer */
|
||||
};
|
||||
struct
|
||||
{
|
||||
u_int16_t source;
|
||||
u_int16_t dest;
|
||||
u_int32_t seq;
|
||||
u_int32_t ack_seq;
|
||||
#ifdef UDP2RAW_LITTLE_ENDIAN
|
||||
u_int16_t res1 : 4;
|
||||
u_int16_t doff : 4;
|
||||
u_int16_t fin : 1;
|
||||
u_int16_t syn : 1;
|
||||
u_int16_t rst : 1;
|
||||
u_int16_t psh : 1;
|
||||
u_int16_t ack : 1;
|
||||
u_int16_t urg : 1;
|
||||
u_int16_t res2 : 2;
|
||||
#else
|
||||
u_int16_t doff : 4;
|
||||
u_int16_t res1 : 4;
|
||||
u_int16_t res2 : 2;
|
||||
u_int16_t urg : 1;
|
||||
u_int16_t ack : 1;
|
||||
u_int16_t psh : 1;
|
||||
u_int16_t rst : 1;
|
||||
u_int16_t syn : 1;
|
||||
u_int16_t fin : 1;
|
||||
#endif
|
||||
u_int16_t window;
|
||||
u_int16_t check;
|
||||
u_int16_t urg_ptr;
|
||||
};
|
||||
};
|
||||
};
|
||||
|
||||
struct my_ip6hdr {
|
||||
#ifdef UDP2RAW_LITTLE_ENDIAN
|
||||
uint8_t traffic_class_high : 4;
|
||||
uint8_t version : 4;
|
||||
uint8_t flow_label_high : 4;
|
||||
uint8_t traffic_class_low : 4;
|
||||
#else
|
||||
uint8_t version : 4;
|
||||
uint8_t traffic_class_high : 4;
|
||||
uint8_t traffic_class_low : 4;
|
||||
uint8_t flow_label_high : 4;
|
||||
#endif
|
||||
u_int16_t flow_label_low;
|
||||
u_int16_t payload_len;
|
||||
@ -158,15 +174,14 @@ struct my_ip6hdr
|
||||
|
||||
struct in6_addr src;
|
||||
struct in6_addr dst;
|
||||
};
|
||||
};
|
||||
|
||||
struct my_icmphdr
|
||||
{
|
||||
uint8_t type;
|
||||
uint8_t code;
|
||||
uint16_t check_sum;
|
||||
uint16_t id;
|
||||
uint16_t seq;
|
||||
struct my_icmphdr {
|
||||
uint8_t type;
|
||||
uint8_t code;
|
||||
uint16_t check_sum;
|
||||
uint16_t id;
|
||||
uint16_t seq;
|
||||
};
|
||||
|
||||
struct pseudo_header {
|
||||
@ -186,55 +201,53 @@ struct pseudo_header6 {
|
||||
u_int8_t next_header;
|
||||
};
|
||||
|
||||
struct packet_info_t //todo change this to union
|
||||
struct packet_info_t // todo change this to union
|
||||
{
|
||||
uint8_t protocol;
|
||||
uint8_t protocol;
|
||||
|
||||
// u32_t src_ip;
|
||||
// u32_t dst_ip;
|
||||
my_ip_t new_src_ip;
|
||||
my_ip_t new_dst_ip;
|
||||
|
||||
//u32_t src_ip;
|
||||
//u32_t dst_ip;
|
||||
my_ip_t new_src_ip;
|
||||
my_ip_t new_dst_ip;
|
||||
uint16_t src_port;
|
||||
uint16_t dst_port;
|
||||
|
||||
uint16_t src_port;
|
||||
uint16_t dst_port;
|
||||
// tcp_part:
|
||||
bool syn, ack, psh, rst;
|
||||
|
||||
//tcp_part:
|
||||
bool syn,ack,psh,rst;
|
||||
u32_t seq, ack_seq;
|
||||
|
||||
u32_t seq,ack_seq;
|
||||
u32_t ack_seq_counter;
|
||||
|
||||
u32_t ack_seq_counter;
|
||||
u32_t ts, ts_ack;
|
||||
|
||||
u32_t ts,ts_ack;
|
||||
uint16_t my_icmp_seq;
|
||||
|
||||
bool has_ts;
|
||||
|
||||
uint16_t my_icmp_seq;
|
||||
i32_t data_len;
|
||||
|
||||
bool has_ts;
|
||||
#ifdef UDP2RAW_LINUX
|
||||
sockaddr_ll addr_ll;
|
||||
#endif
|
||||
|
||||
sockaddr_ll addr_ll;
|
||||
|
||||
i32_t data_len;
|
||||
|
||||
packet_info_t();
|
||||
packet_info_t();
|
||||
};
|
||||
|
||||
struct raw_info_t
|
||||
{
|
||||
packet_info_t send_info;
|
||||
packet_info_t recv_info;
|
||||
//int last_send_len;
|
||||
//int last_recv_len;
|
||||
bool peek=0;
|
||||
//bool csum=1;
|
||||
u32_t reserved_send_seq;
|
||||
//uint32_t first_seq,first_ack_seq;
|
||||
int rst_received=0;
|
||||
bool disabled=0;
|
||||
|
||||
};//g_raw_info;
|
||||
struct raw_info_t {
|
||||
packet_info_t send_info;
|
||||
packet_info_t recv_info;
|
||||
// int last_send_len;
|
||||
// int last_recv_len;
|
||||
bool peek = 0;
|
||||
// bool csum=1;
|
||||
u32_t reserved_send_seq;
|
||||
// uint32_t first_seq,first_ack_seq;
|
||||
int rst_received = 0;
|
||||
bool disabled = 0;
|
||||
|
||||
}; // g_raw_info;
|
||||
|
||||
int init_raw_socket();
|
||||
|
||||
@ -242,51 +255,56 @@ void init_filter(int port);
|
||||
|
||||
void remove_filter();
|
||||
|
||||
int init_ifindex(const char * if_name,int fd,int &index);
|
||||
#ifdef UDP2RAW_LINUX
|
||||
int init_ifindex(const char *if_name, int fd, int &index);
|
||||
#endif
|
||||
|
||||
int find_lower_level_info(u32_t ip,u32_t &dest_ip,string &if_name,string &hw);
|
||||
#ifdef UDP2RAW_MP
|
||||
int init_ifindex(const char *if_name, int &index);
|
||||
#endif
|
||||
|
||||
int get_src_adress(u32_t &ip,u32_t remote_ip_uint32,int remote_port); //a trick to get src adress for a dest adress,so that we can use the src address in raw socket as source ip
|
||||
int get_src_adress2(address_t &output_addr,address_t remote_addr);
|
||||
int find_lower_level_info(u32_t ip, u32_t &dest_ip, string &if_name, string &hw);
|
||||
|
||||
int try_to_list_and_bind(int & bind_fd,u32_t local_ip_uint32,int port); //try to bind to a port,may fail.
|
||||
int try_to_list_and_bind2(int &fd,address_t address);
|
||||
int get_src_adress(u32_t &ip, u32_t remote_ip_uint32, int remote_port); // a trick to get src adress for a dest adress,so that we can use the src address in raw socket as source ip
|
||||
int get_src_adress2(address_t &output_addr, address_t remote_addr);
|
||||
|
||||
int client_bind_to_a_new_port(int & bind_fd,u32_t local_ip_uint32);//find a free port and bind to it.
|
||||
int client_bind_to_a_new_port2(int &fd,const address_t& address);
|
||||
int try_to_list_and_bind(int &bind_fd, u32_t local_ip_uint32, int port); // try to bind to a port,may fail.
|
||||
int try_to_list_and_bind2(int &fd, address_t address);
|
||||
|
||||
int client_bind_to_a_new_port(int &bind_fd, u32_t local_ip_uint32); // find a free port and bind to it.
|
||||
int client_bind_to_a_new_port2(int &fd, const address_t &address);
|
||||
|
||||
int discard_raw_packet();
|
||||
int pre_recv_raw_packet();
|
||||
|
||||
int send_raw_ip(raw_info_t &raw_info,const char * payload,int payloadlen);
|
||||
int send_raw_ip(raw_info_t &raw_info, const char *payload, int payloadlen);
|
||||
|
||||
int peek_raw(raw_info_t &peek_info);
|
||||
|
||||
int recv_raw_ip(raw_info_t &raw_info,char * &payload,int &payloadlen);
|
||||
int recv_raw_ip(raw_info_t &raw_info, char *&payload, int &payloadlen);
|
||||
|
||||
int send_raw_icmp(raw_info_t &raw_info, const char * payload, int payloadlen);
|
||||
int send_raw_icmp(raw_info_t &raw_info, const char *payload, int payloadlen);
|
||||
|
||||
int send_raw_udp(raw_info_t &raw_info, const char * payload, int payloadlen);
|
||||
int send_raw_udp(raw_info_t &raw_info, const char *payload, int payloadlen);
|
||||
|
||||
int send_raw_tcp(raw_info_t &raw_info,const char * payload, int payloadlen);
|
||||
int send_raw_tcp(raw_info_t &raw_info, const char *payload, int payloadlen);
|
||||
|
||||
int recv_raw_icmp(raw_info_t &raw_info, char *&payload, int &payloadlen);
|
||||
|
||||
int recv_raw_udp(raw_info_t &raw_info, char *&payload, int &payloadlen);
|
||||
|
||||
int recv_raw_tcp(raw_info_t &raw_info,char * &payload,int &payloadlen);
|
||||
int recv_raw_tcp(raw_info_t &raw_info, char *&payload, int &payloadlen);
|
||||
|
||||
//int send_raw(raw_info_t &raw_info,const char * payload,int payloadlen);
|
||||
// int send_raw(raw_info_t &raw_info,const char * payload,int payloadlen);
|
||||
|
||||
//int recv_raw(raw_info_t &raw_info,char * &payload,int &payloadlen);
|
||||
// int recv_raw(raw_info_t &raw_info,char * &payload,int &payloadlen);
|
||||
|
||||
int send_raw0(raw_info_t &raw_info,const char * payload,int payloadlen);
|
||||
int send_raw0(raw_info_t &raw_info, const char *payload, int payloadlen);
|
||||
|
||||
int recv_raw0(raw_info_t &raw_info,char * &payload,int &payloadlen);
|
||||
int recv_raw0(raw_info_t &raw_info, char *&payload, int &payloadlen);
|
||||
|
||||
int after_send_raw0(raw_info_t &raw_info);
|
||||
|
||||
int after_recv_raw0(raw_info_t &raw_info);
|
||||
|
||||
|
||||
#endif /* NETWORK_H_ */
|
||||
|
||||
119
pcap_wrapper.cpp
Normal file
119
pcap_wrapper.cpp
Normal file
@ -0,0 +1,119 @@
|
||||
#include <windows.h>
|
||||
#include <pcap_wrapper.h>
|
||||
#include <assert.h>
|
||||
#include <stdio.h>
|
||||
int (*pcap_loop)(pcap_t *, int, pcap_handler, u_char *);
|
||||
int (*pcap_breakloop)(pcap_t *);
|
||||
|
||||
pcap_t *(*pcap_create)(const char *, char *);
|
||||
|
||||
int (*pcap_set_snaplen)(pcap_t *, int) = 0;
|
||||
int (*pcap_set_promisc)(pcap_t *, int) = 0;
|
||||
int (*pcap_can_set_rfmon)(pcap_t *) = 0;
|
||||
int (*pcap_set_rfmon)(pcap_t *, int) = 0;
|
||||
int (*pcap_set_timeout)(pcap_t *, int) = 0;
|
||||
int (*pcap_set_buffer_size)(pcap_t *, int) = 0;
|
||||
int (*pcap_activate)(pcap_t *) = 0;
|
||||
|
||||
int (*pcap_setfilter)(pcap_t *, struct bpf_program *) = 0;
|
||||
int (*pcap_setdirection)(pcap_t *, pcap_direction_t) = 0;
|
||||
|
||||
int (*pcap_datalink)(pcap_t *) = 0;
|
||||
|
||||
void (*pcap_freecode)(struct bpf_program *) = 0;
|
||||
|
||||
int (*pcap_compile)(pcap_t *, struct bpf_program *, const char *, int,
|
||||
bpf_u_int32) = 0;
|
||||
|
||||
char *(*pcap_geterr)(pcap_t *) = 0;
|
||||
int (*pcap_sendpacket)(pcap_t *, const u_char *, int) = 0;
|
||||
|
||||
char *(*pcap_lookupdev)(char *) = 0;
|
||||
|
||||
int (*pcap_findalldevs)(pcap_if_t **, char *) = 0;
|
||||
|
||||
struct init_pcap_t {
|
||||
init_pcap_t() {
|
||||
init_pcap();
|
||||
}
|
||||
|
||||
} do_it;
|
||||
|
||||
static void init_npcap_dll_path() {
|
||||
BOOL(WINAPI * SetDllDirectory)
|
||||
(LPCTSTR);
|
||||
char sysdir_name[512];
|
||||
int len;
|
||||
|
||||
SetDllDirectory = (BOOL(WINAPI *)(LPCTSTR))GetProcAddress(GetModuleHandle("kernel32.dll"), "SetDllDirectoryA");
|
||||
if (SetDllDirectory == NULL) {
|
||||
printf("Error in SetDllDirectory\n");
|
||||
} else {
|
||||
len = GetSystemDirectory(sysdir_name, 480); // be safe
|
||||
if (!len)
|
||||
printf("Error in GetSystemDirectory (%d)\n", (int)GetLastError());
|
||||
strcat(sysdir_name, "\\Npcap");
|
||||
if (SetDllDirectory(sysdir_name) == 0)
|
||||
printf("Error in SetDllDirectory(\"System32\\Npcap\")\n");
|
||||
}
|
||||
}
|
||||
|
||||
#define EXPORT_FUN(XXX) \
|
||||
do { \
|
||||
XXX = (__typeof__(XXX))GetProcAddress(wpcap, #XXX); \
|
||||
} while (0)
|
||||
int init_pcap() {
|
||||
HMODULE wpcap = LoadLibrary("wpcap.dll");
|
||||
if (wpcap != 0) {
|
||||
printf("using system32/wpcap.dll\n");
|
||||
} else {
|
||||
init_npcap_dll_path();
|
||||
// SetDllDirectory("C:\\Windows\\System32\\Npcap\\");
|
||||
wpcap = LoadLibrary("wpcap.dll");
|
||||
if (wpcap != 0)
|
||||
printf("using system32/npcap/wpcap.dll\n");
|
||||
}
|
||||
if (wpcap == 0) {
|
||||
printf("cant not open wpcap.dll, make sure winpcap/npcap is installed\n");
|
||||
exit(-1);
|
||||
}
|
||||
assert(wpcap != 0);
|
||||
|
||||
EXPORT_FUN(pcap_loop);
|
||||
EXPORT_FUN(pcap_breakloop);
|
||||
EXPORT_FUN(pcap_create);
|
||||
EXPORT_FUN(pcap_set_snaplen);
|
||||
EXPORT_FUN(pcap_set_promisc);
|
||||
EXPORT_FUN(pcap_set_timeout);
|
||||
EXPORT_FUN(pcap_activate);
|
||||
EXPORT_FUN(pcap_setfilter);
|
||||
EXPORT_FUN(pcap_setdirection);
|
||||
EXPORT_FUN(pcap_datalink);
|
||||
EXPORT_FUN(pcap_freecode);
|
||||
EXPORT_FUN(pcap_compile);
|
||||
EXPORT_FUN(pcap_geterr);
|
||||
EXPORT_FUN(pcap_sendpacket);
|
||||
EXPORT_FUN(pcap_lookupdev);
|
||||
EXPORT_FUN(pcap_findalldevs);
|
||||
/*
|
||||
pcap_loop = (__typeof__(pcap_loop))GetProcAddress(wpcap, "pcap_loop");
|
||||
pcap_create = (__typeof__(pcap_create))GetProcAddress(wpcap, "pcap_create");
|
||||
pcap_set_snaplen = (__typeof__(pcap_set_snaplen))GetProcAddress(wpcap, "pcap_set_snaplen");
|
||||
pcap_set_promisc = (__typeof__(pcap_set_promisc))GetProcAddress(wpcap, "pcap_set_promisc");
|
||||
pcap_set_timeout = (__typeof__(pcap_set_timeout))GetProcAddress(wpcap, "pcap_set_timeout");
|
||||
pcap_activate = (__typeof__(pcap_activate))GetProcAddress(wpcap, "pcap_activate");
|
||||
pcap_setfilter = (__typeof__(pcap_setfilter))GetProcAddress(wpcap, "pcap_setfilter");
|
||||
pcap_setdirection = (__typeof__(pcap_setdirection))GetProcAddress(wpcap, "pcap_setdirection");
|
||||
pcap_datalink = (__typeof__(pcap_datalink))GetProcAddress(wpcap, "pcap_datalink");
|
||||
pcap_freecode = (__typeof__(pcap_freecode))GetProcAddress(wpcap, "pcap_freecode");
|
||||
pcap_compile = (__typeof__(pcap_compile))GetProcAddress(wpcap, "pcap_compile");
|
||||
pcap_geterr = (__typeof__(pcap_geterr))GetProcAddress(wpcap, "pcap_geterr");
|
||||
pcap_sendpacket = (__typeof__(pcap_sendpacket))GetProcAddress(wpcap, "pcap_sendpacket");
|
||||
pcap_lookupdev = (__typeof__(pcap_lookupdev))GetProcAddress(wpcap, "pcap_lookupdev");
|
||||
pcap_findalldevs = (__typeof__(pcap_findalldevs))GetProcAddress(wpcap, "pcap_findalldevs");
|
||||
//pcap_loop = (__typeof__(pcap_loop))GetProcAddress(wpcap, "pcap_loop");
|
||||
//pcap_loop = (__typeof__(pcap_loop))GetProcAddress(wpcap, "pcap_loop");
|
||||
//pcap_loop = (__typeof__(pcap_loop))GetProcAddress(wpcap, "pcap_loop");
|
||||
*/
|
||||
return 0;
|
||||
}
|
||||
117
pcap_wrapper.h
Normal file
117
pcap_wrapper.h
Normal file
@ -0,0 +1,117 @@
|
||||
#pragma once
|
||||
|
||||
//#ifdef __cplusplus
|
||||
// extern "C" {
|
||||
//#endif
|
||||
|
||||
//#include <sys/time.h>
|
||||
//#include <stdint.h>
|
||||
|
||||
struct bpf_program {
|
||||
char a[4096];
|
||||
};
|
||||
|
||||
struct pcap_t {
|
||||
char a[4096];
|
||||
};
|
||||
|
||||
typedef unsigned int bpf_u_int32;
|
||||
|
||||
typedef struct my_timeval {
|
||||
int tv_sec;
|
||||
int tv_usec;
|
||||
} my_timeval;
|
||||
|
||||
struct pcap_pkthdr {
|
||||
struct my_timeval ts; /* time stamp */
|
||||
bpf_u_int32 caplen; /* length of portion present */
|
||||
bpf_u_int32 len; /* length this packet (off wire) */
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
PCAP_D_INOUT = 0,
|
||||
PCAP_D_IN,
|
||||
PCAP_D_OUT
|
||||
} pcap_direction_t;
|
||||
|
||||
struct pcap_addr {
|
||||
struct pcap_addr *next;
|
||||
struct sockaddr *addr; /* address */
|
||||
struct sockaddr *netmask; /* netmask for that address */
|
||||
struct sockaddr *broadaddr; /* broadcast address for that address */
|
||||
struct sockaddr *dstaddr; /* P2P destination address for that address */
|
||||
};
|
||||
|
||||
struct pcap_if {
|
||||
struct pcap_if *next;
|
||||
char *name; /* name to hand to "pcap_open_live()" */
|
||||
char *description; /* textual description of interface, or NULL */
|
||||
struct pcap_addr *addresses;
|
||||
bpf_u_int32 flags; /* PCAP_IF_ interface flags */
|
||||
};
|
||||
|
||||
typedef struct pcap_if pcap_if_t;
|
||||
typedef struct pcap_addr pcap_addr_t;
|
||||
|
||||
typedef unsigned char u_char;
|
||||
|
||||
#define PCAP_ERRBUF_SIZE 256
|
||||
|
||||
#define DLT_NULL 0 /* BSD loopback encapsulation */
|
||||
#define DLT_EN10MB 1 /* Ethernet (10Mb) */
|
||||
#define DLT_EN3MB 2 /* Experimental Ethernet (3Mb) */
|
||||
#define DLT_AX25 3 /* Amateur Radio AX.25 */
|
||||
#define DLT_PRONET 4 /* Proteon ProNET Token Ring */
|
||||
#define DLT_CHAOS 5 /* Chaos */
|
||||
#define DLT_IEEE802 6 /* 802.5 Token Ring */
|
||||
#define DLT_ARCNET 7 /* ARCNET, with BSD-style header */
|
||||
#define DLT_SLIP 8 /* Serial Line IP */
|
||||
#define DLT_PPP 9 /* Point-to-point Protocol */
|
||||
#define DLT_FDDI 10 /* FDDI */
|
||||
#define DLT_LINUX_SLL 113
|
||||
|
||||
#define PCAP_NETMASK_UNKNOWN 0xffffffff
|
||||
|
||||
typedef void (*pcap_handler)(u_char *, const struct pcap_pkthdr *,
|
||||
const u_char *);
|
||||
|
||||
extern int (*pcap_loop)(pcap_t *, int, pcap_handler, u_char *);
|
||||
|
||||
extern int (*pcap_breakloop)(pcap_t *);
|
||||
|
||||
extern pcap_t *(*pcap_create)(const char *, char *);
|
||||
|
||||
extern int (*pcap_set_snaplen)(pcap_t *, int);
|
||||
extern int (*pcap_set_promisc)(pcap_t *, int);
|
||||
extern int (*pcap_can_set_rfmon)(pcap_t *);
|
||||
extern int (*pcap_set_rfmon)(pcap_t *, int);
|
||||
extern int (*pcap_set_timeout)(pcap_t *, int);
|
||||
extern int (*pcap_set_buffer_size)(pcap_t *, int);
|
||||
extern int (*pcap_activate)(pcap_t *);
|
||||
|
||||
extern int (*pcap_setfilter)(pcap_t *, struct bpf_program *);
|
||||
extern int (*pcap_setdirection)(pcap_t *, pcap_direction_t);
|
||||
|
||||
extern int (*pcap_datalink)(pcap_t *);
|
||||
|
||||
extern void (*pcap_freecode)(struct bpf_program *);
|
||||
|
||||
extern int (*pcap_compile)(pcap_t *, struct bpf_program *, const char *, int,
|
||||
bpf_u_int32);
|
||||
|
||||
extern char *(*pcap_geterr)(pcap_t *);
|
||||
extern int (*pcap_sendpacket)(pcap_t *, const u_char *, int);
|
||||
|
||||
extern char *(*pcap_lookupdev)(char *);
|
||||
|
||||
extern int (*pcap_findalldevs)(pcap_if_t **, char *);
|
||||
|
||||
inline int pcap_set_immediate_mode(pcap_t *, int) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
//#ifdef __cplusplus
|
||||
//}
|
||||
//#endif
|
||||
|
||||
int init_pcap();
|
||||
1421
server.cpp
1421
server.cpp
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue
Block a user