mirrors/youtubeUnblock
1
0
Fork 0
mirror of https://github.com/Waujito/youtubeUnblock.git synced 2024-12-22 14:26:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Initial commit.

Browse Source 
The package works with firefox.
This commit is contained in:
Vadim Vetrov 2024-07-21 17:44:46 +03:00
parent 4f567dfd77
commit 3e44760a88
No known key found for this signature in database
GPG Key ID: E8A308689D7A73A5
3 changed files with 712 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.gitignore vendored Normal file
View File

@ -0,0 +1,4 @@
compile_commands.json
.cache
build

39
Makefile Normal file
View File

@ -0,0 +1,39 @@
CC := gcc
CC_FLAGS:=-Wall -Wpedantic -Wno-unused-variable
LD_FLAGS:=-lmnl -lnetfilter_queue
BUILD_DIR:=build
APP:=$(BUILD_DIR)/youtubeUnblock
SRCS := youtubeUnblock.c
OBJS := $(SRCS:%.c=$(BUILD_DIR)/%.o)
.PHONY: default all dev dev_attrs prepare_dirs
default: all
run_dev: dev
bash -c "sudo ./$(APP) 2"
dev: dev_attrs all
dev_attrs:
$(eval CC_FLAGS := $(CC_FLAGS) -DDEBUG -ggdb -g3)
all: prepare_dirs $(APP)
prepare_dirs:
mkdir -p $(BUILD_DIR)
$(APP): $(OBJS)
@echo 'LD $(APP)'
@$(CC) $(OBJS) -o $(APP) $(LD_FLAGS)
$(BUILD_DIR)/%.o: %.c
@echo 'CC $@'
@$(CC) -c $(CC_FLAGS) $^ -o $@
clean:
rm -rf $(BUILD_DIR)

669
youtubeUnblock.c Normal file
View File

@ -0,0 +1,669 @@
#include <libnetfilter_queue/linux_nfnetlink_queue.h>
#include <stdio.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <arpa/inet.h>
#include <libmnl/libmnl.h>
#include <libnetfilter_queue/libnetfilter_queue.h>
#include <libnetfilter_queue/libnetfilter_queue_ipv4.h>
#include <libnetfilter_queue/libnetfilter_queue_tcp.h>
#include <libnetfilter_queue/libnetfilter_queue_udp.h>
#include <libnetfilter_queue/pktbuff.h>
#include <netinet/ip.h>
#include <netinet/tcp.h>
#include <netinet/udp.h>
#include <linux/netfilter.h>
#include <linux/if_ether.h>
#include <sys/socket.h>
#define RAWSOCKET_MARK 0xfc70
static struct {
uint32_t queue_num;
struct mnl_socket *nl;
uint32_t portid;
int rawsocket;
} config = {
.rawsocket = -2
};
static int parse_args(int argc, const char *argv[]) {
int err;
char *end;
if (argc != 2) {
errno = EINVAL;
goto errormsg_help;
}
uint32_t queue_num = strtoul(argv[1], &end, 10);
if (errno != 0 || *end != '\0') goto errormsg_help;
config.queue_num = queue_num;
return 0;
errormsg_help:
err = errno;
printf("Usage: %s [queue_num]\n", argv[0]);
errno = err;
if (errno == 0) errno = EINVAL;
return -1;
}
static int open_socket(void) {
if (config.nl != NULL) {
errno = EALREADY;
perror("socket is already opened");
return -1;
}
struct mnl_socket *nl = NULL;
nl = mnl_socket_open(NETLINK_NETFILTER);
if (nl == NULL) {
perror("mnl_socket_open");
return -1;
}
if (mnl_socket_bind(nl, 0, MNL_SOCKET_AUTOPID) < 0) {
perror("mnl_socket_bind");
mnl_socket_close(nl);
return -1;
}
config.nl = nl;
config.portid = mnl_socket_get_portid(nl);
return 0;
}
static int close_socket(void) {
if (config.nl == NULL) return 1;
if (mnl_socket_close(config.nl) < 0) {
perror("mnl_socket_close");
return -1;
}
config.nl = NULL;
return 0;
}
static int open_raw_socket(void) {
if (config.rawsocket != -2) {
errno = EALREADY;
perror("Raw socket is already opened");
return -1;
}
config.rawsocket = socket(AF_INET, SOCK_RAW, IPPROTO_RAW);
if (config.rawsocket == -1) {
perror("Unable to create raw socket");
return -1;
}
int one = 1;
const int *val = &one;
if (setsockopt(config.rawsocket, IPPROTO_IP, IP_HDRINCL, val, sizeof(one)) < 0)
{
printf("setsockopt(IP_HDRINCL, 1) failed\n");
return -1;
}
int mark = RAWSOCKET_MARK;
if (setsockopt(config.rawsocket, SOL_SOCKET, SO_MARK, &mark, sizeof(mark)) < 0)
{
printf("setsockopt(SO_MARK, %d) failed\n", mark);
return -1;
}
return config.rawsocket;
}
static int close_raw_socket(void) {
if (config.rawsocket < 0) {
errno = EALREADY;
perror("Raw socket is not set");
return -1;
}
if (close(config.rawsocket)) {
perror("Unable to close raw socket");
return -1;
}
config.rawsocket = -2;
return 0;
}
static int send_raw_socket(struct pkt_buff *pktb) {
struct iphdr *iph = nfq_ip_get_hdr(pktb);
if (iph == NULL)
return -1;
if(nfq_ip_set_transport_header(pktb, iph))
return -1;
int sin_port = 0;
struct tcphdr *tcph = nfq_tcp_get_hdr(pktb);
struct udphdr *udph = nfq_udp_get_hdr(pktb);
if (tcph != NULL) {
sin_port = tcph->dest;
} else if (udph != NULL) {
sin_port = udph->dest;
} else {
return -1;
}
struct sockaddr_in daddr = {
.sin_family = AF_INET,
.sin_port = sin_port,
.sin_addr = {
.s_addr = iph->daddr
}
};
int sent = sendto(config.rawsocket,
pktb_data(pktb), pktb_len(pktb), 0,
(struct sockaddr *)&daddr, sizeof(daddr));
return sent;
}
struct packet_data {
uint32_t id;
uint16_t hw_proto;
uint8_t hook;
void *payload;
uint16_t payload_len;
};
/**
* Used to accept unsupported packets (GSOs)
*/
static int fallback_accept_packet(uint32_t id) {
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *verdnlh;
verdnlh = nfq_nlmsg_put(buf, NFQNL_MSG_VERDICT, config.queue_num);
nfq_nlmsg_verdict_put(verdnlh, id, NF_ACCEPT);
if (mnl_socket_sendto(config.nl, verdnlh, verdnlh->nlmsg_len) < 0) {
perror("mnl_socket_send");
return MNL_CB_ERROR;
}
return MNL_CB_OK;
}
#define TLS_CONTENT_TYPE_HANDSHAKE 0x16
#define TLS_HANDSHAKE_TYPE_CLIENT_HELLO 0x01
#define TLS_EXTENSION_SNI 0x0000
#define TLS_EXTENSION_CLIENT_HELLO_ENCRYPTED 0xfe0d
const char googlevideo_ending[] = "googlevideo.com";
const int googlevideo_len = 15;
#define GOOGLEVIDEO_MARK 0xfc74
struct verdict {
int gvideo_hello; /* google video hello packet */
int sni_offset; /* offset from start of tcp _payload_ */
int sni_len;
};
/**
* Processes tls payload of the tcp request.
*
* data Payload data of TCP.
* dlen Length of `data`.
*/
static struct verdict process_tls_data(
struct pkt_buff *pktb,
struct tcphdr *tcph,
uint8_t *data,
uint32_t dlen)
{
struct verdict vrd = {0};
size_t i = 0;
uint8_t *data_end = data + dlen;
while (i + 4 < dlen) {
uint8_t *msgData = data + i;
uint8_t tls_content_type = *msgData;
uint8_t tls_vmajor = *(msgData + 1);
uint8_t tls_vminor = *(msgData + 2);
uint16_t message_length = ntohs(*(uint16_t *)(msgData + 3));
uint8_t *message_length_ptr = msgData + 3;
if (i + 5 + message_length > dlen) break;
if (tls_content_type != TLS_CONTENT_TYPE_HANDSHAKE)
goto nextMessage;
uint8_t *handshakeProto = msgData + 5;
if (handshakeProto + 1 >= data_end) break;
uint8_t handshakeType = *handshakeProto;
if (handshakeType != TLS_HANDSHAKE_TYPE_CLIENT_HELLO)
goto nextMessage;
uint8_t *msgPtr = handshakeProto;
msgPtr += 1;
uint8_t *handshakeProto_length_ptr = msgPtr + 1;
msgPtr += 3 + 2 + 32;
if (msgPtr + 1 >= data_end) break;
uint8_t sessionIdLength = *msgPtr;
msgPtr++;
msgPtr += sessionIdLength;
if (msgPtr + 2 >= data_end) break;
uint16_t ciphersLength = ntohs(*(uint16_t *)msgPtr);
msgPtr += 2;
msgPtr += ciphersLength;
if (msgPtr + 1 >= data_end) break;
uint8_t compMethodsLen = *msgPtr;
msgPtr++;
msgPtr += compMethodsLen;
if (msgPtr + 2 >= data_end) break;
uint16_t extensionsLen = ntohs(*(uint16_t *)msgPtr);
uint8_t *extensionsLen_ptr = msgPtr;
msgPtr += 2;
uint8_t *extensionsPtr = msgPtr;
uint8_t *extensions_end = extensionsPtr + extensionsLen;
if (extensions_end > data_end) break;
while (extensionsPtr < extensions_end) {
uint8_t *extensionPtr = extensionsPtr;
if (extensionPtr + 4 >= extensions_end) break;
uint16_t extensionType =
ntohs(*(uint16_t *)extensionPtr);
extensionPtr += 2;
uint16_t extensionLen =
ntohs(*(uint16_t *)extensionPtr);
uint8_t *extensionLen_ptr = extensionPtr;
extensionPtr += 2;
if (extensionPtr + extensionLen > extensions_end)
break;
if (extensionType != TLS_EXTENSION_SNI)
goto nextExtension;
uint8_t *sni_ext_ptr = extensionPtr;
if (sni_ext_ptr + 2 >= extensions_end) break;
uint16_t sni_ext_dlen = ntohs(*(uint16_t *)sni_ext_ptr);
uint8_t *sni_ext_dlen_ptr = sni_ext_ptr;
sni_ext_ptr += 2;
uint8_t *sni_ext_end = sni_ext_ptr + sni_ext_dlen;
if (sni_ext_end >= extensions_end) break;
if (sni_ext_ptr + 3 >= sni_ext_end) break;
uint8_t sni_type = *sni_ext_ptr++;
uint16_t sni_len = ntohs(*(uint16_t *)sni_ext_ptr);
sni_ext_ptr += 2;
if (sni_ext_ptr + sni_len > sni_ext_end) break;
char *sni_name = (char *)sni_ext_ptr;
// sni_len
vrd.sni_offset = (uint8_t *)sni_name - data;
vrd.sni_len = sni_len;
char *gv_startp = sni_name + sni_len - googlevideo_len;
if (sni_len >= googlevideo_len &&
sni_len < 128 &&
!strncmp(gv_startp,
googlevideo_ending,
googlevideo_len)) {
vrd.gvideo_hello = 1;
}
nextExtension:
extensionsPtr += 2 + 2 + extensionLen;
}
nextMessage:
i += 5 + message_length;
}
return vrd;
}
// split packet to two ipv4 fragments.
static int ipv4_frag(struct pkt_buff *pktb, size_t payload_offset,
struct pkt_buff **frag1, struct pkt_buff **frag2) {
uint8_t buff1[MNL_SOCKET_BUFFER_SIZE];
uint8_t buff2[MNL_SOCKET_BUFFER_SIZE];
struct iphdr *hdr = nfq_ip_get_hdr(pktb);
size_t hdr_len = hdr->ihl * 4;
uint8_t *payload = pktb_data(pktb) + hdr_len;
size_t plen = pktb_len(pktb) - hdr_len;
if (hdr == NULL || payload == NULL || plen <= payload_offset) {
errno = EINVAL;
return -1;
}
if (payload_offset & ((1 << 3) - 1)) {
fprintf(stderr, "Payload offset MUST be a multiply of 8!\n");
errno = EINVAL;
return -1;
}
size_t f1_plen = payload_offset;
size_t f1_dlen = f1_plen + hdr_len;
size_t f2_plen = plen - payload_offset;
size_t f2_dlen = f2_plen + hdr_len;
memcpy(buff1, hdr, hdr_len);
memcpy(buff2, hdr, hdr_len);
memcpy(buff1 + hdr_len, payload, f1_plen);
memcpy(buff2 + hdr_len, payload + payload_offset, f2_plen);
struct iphdr *f1_hdr = (void *)buff1;
struct iphdr *f2_hdr = (void *)buff2;
uint16_t f1_frag_off = ntohs(f1_hdr->frag_off);
uint16_t f2_frag_off = ntohs(f2_hdr->frag_off);
f1_frag_off &= IP_OFFMASK;
f1_frag_off |= IP_MF;
if ((f2_frag_off & ~IP_OFFMASK) == IP_MF) {
f2_frag_off &= IP_OFFMASK;
f2_frag_off |= IP_MF;
} else {
f2_frag_off &= IP_OFFMASK;
}
f2_frag_off += (uint16_t)payload_offset / 8;
f1_hdr->frag_off = htons(f1_frag_off);
f1_hdr->tot_len = htons(f1_dlen);
f2_hdr->frag_off = htons(f2_frag_off);
f2_hdr->tot_len = htons(f2_dlen);
*frag1 = pktb_alloc(AF_INET, buff1, f1_dlen, 256);
*frag2 = pktb_alloc(AF_INET, buff2, f2_dlen, 256);
nfq_ip_set_checksum(f1_hdr);
nfq_ip_set_checksum(f2_hdr);
return 0;
}
static int process_packet(const struct packet_data packet) {
char buf[MNL_SOCKET_BUFFER_SIZE];
struct nlmsghdr *verdnlh;
#ifdef DEBUG_LOGGING
printf("packet received (id=%u hw=0x%04x hook=%u, payload len %u)\n",
packet.id, packet.hw_proto, packet.hook, packet.payload_len);
#endif
if (packet.hw_proto != ETH_P_IP) {
return fallback_accept_packet(packet.id);
}
const int family = AF_INET;
struct pkt_buff *pktb = pktb_alloc(
family,
packet.payload,
packet.payload_len,
256
);
if (pktb == NULL) {
perror("pktb_alloc");
return MNL_CB_ERROR;
}
struct iphdr *ip_header = nfq_ip_get_hdr(pktb);
if (ip_header == NULL) {
perror("get_ip_hdr");
goto error;
}
if (ip_header->protocol != IPPROTO_TCP) {
goto fallback;
}
if (nfq_ip_set_transport_header(pktb, ip_header)) {
perror("set_transport_header\n");
goto fallback;
}
struct tcphdr *tcph = nfq_tcp_get_hdr(pktb);
if (tcph == NULL) {
fprintf(stderr, "tcp_get_hdr\n");
goto fallback;
}
void *data = nfq_tcp_get_payload(tcph, pktb);
ssize_t data_len = nfq_tcp_get_payload_len(tcph, pktb);
struct verdict vrd =
process_tls_data(pktb, tcph, data, data_len);
verdnlh = nfq_nlmsg_put(buf, NFQNL_MSG_VERDICT, config.queue_num);
nfq_nlmsg_verdict_put(verdnlh, packet.id, NF_ACCEPT);
if (vrd.gvideo_hello) {
#ifdef DEBUG
printf("Google video!\n");
#endif
if (data_len > 1480) {
fprintf(stderr, "WARNING! Google video packet is too big and may cause issues! Skipped!");
goto fallback;
}
nfq_nlmsg_verdict_put(verdnlh, packet.id, NF_DROP);
size_t ipd_offset = ((char *)data - (char *)tcph) + vrd.sni_offset;
size_t mid_offset = ipd_offset + vrd.sni_len / 2;
mid_offset += 8 - mid_offset % 8;
struct pkt_buff *frag1;
struct pkt_buff *frag2;
if (ipv4_frag(pktb, mid_offset, &frag1, &frag2) < 0) {
perror("ipv4_frag");
goto fallback;
}
if ((send_raw_socket(frag1) == -1) || (send_raw_socket(frag2) == -1)) {
perror("raw frags send");
}
pktb_free(frag1);
pktb_free(frag2);
}
if (pktb_mangled(pktb)) {
#ifdef DEBUG
printf("Mangled!\n");
#endif
nfq_nlmsg_verdict_put_pkt(
verdnlh, pktb_data(pktb), pktb_len(pktb));
}
if (mnl_socket_sendto(config.nl, verdnlh, verdnlh->nlmsg_len) < 0) {
perror("mnl_socket_send");
goto error;
}
pktb_free(pktb);
return MNL_CB_OK;
fallback:
pktb_free(pktb);
return fallback_accept_packet(packet.id);
error:
pktb_free(pktb);
return MNL_CB_ERROR;
}
static int queue_cb(const struct nlmsghdr *nlh, void *data) {
struct nfqnl_msg_packet_hdr *ph = NULL;
struct nlattr *attr[NFQA_MAX+1] = {0};
struct packet_data packet = {0};
if (nfq_nlmsg_parse(nlh, attr) < 0) {
perror("Attr parse");
return MNL_CB_ERROR;
}
if (attr[NFQA_PACKET_HDR] == NULL) {
errno = ENODATA;
perror("Metaheader not set");
return MNL_CB_ERROR;
}
ph = mnl_attr_get_payload(attr[NFQA_PACKET_HDR]);
packet.id = ntohl(ph->packet_id);
packet.hw_proto = ntohs(ph->hw_protocol);
packet.hook = ph->hook;
packet.payload_len = mnl_attr_get_payload_len(attr[NFQA_PAYLOAD]);
packet.payload = mnl_attr_get_payload(attr[NFQA_PAYLOAD]);
uint32_t skbinfo = attr[NFQA_SKB_INFO]
? ntohl(mnl_attr_get_u32(attr[NFQA_SKB_INFO])) : 0;
if (skbinfo & NFQA_SKB_GSO) {
printf("GSO!\n");
return fallback_accept_packet(packet.id);
}
if (skbinfo & NFQA_SKB_CSUMNOTREADY) {
printf("checksum not ready\n");
return fallback_accept_packet(packet.id);
}
return process_packet(packet);
}
int main(int argc, const char *argv[])
{
if (parse_args(argc, argv)) {
perror("Unable to parse args");
exit(EXIT_FAILURE);
}
if (open_socket()) {
perror("Unable to open socket");
exit(EXIT_FAILURE);
}
if (open_raw_socket() < 0) {
perror("Unable to open raw socket");
close_socket();
exit(EXIT_FAILURE);
}
struct nlmsghdr *nlh;
char *buf;
size_t buf_size = 0xffff + (MNL_SOCKET_BUFFER_SIZE / 2);
buf = malloc(buf_size);
if (!buf) {
perror("Allocate recieve buffer");
goto die_sock;
}
nlh = nfq_nlmsg_put(buf, NFQNL_MSG_CONFIG, config.queue_num);
nfq_nlmsg_cfg_put_cmd(nlh, AF_INET, NFQNL_CFG_CMD_BIND);
if (mnl_socket_sendto(config.nl, nlh, nlh->nlmsg_len) < 0) {
perror("mnl_socket_send");
goto die_buf;
}
nlh = nfq_nlmsg_put(buf, NFQNL_MSG_CONFIG, config.queue_num);
nfq_nlmsg_cfg_put_params(nlh, NFQNL_COPY_PACKET, 0xffff);
// mnl_attr_put_u32(nlh, NFQA_CFG_FLAGS, htonl(NFQA_CFG_F_GSO));
// mnl_attr_put_u32(nlh, NFQA_CFG_MASK, htonl(NFQA_CFG_F_GSO));
if (mnl_socket_sendto(config.nl, nlh, nlh->nlmsg_len) < 0) {
perror("mnl_socket_send");
goto die_buf;
}
/* ENOBUFS is signalled to userspace when packets were lost
* on kernel side. In most cases, userspace isn't interested
* in this information, so turn it off.
*/
int ret = 1;
mnl_socket_setsockopt(config.nl, NETLINK_NO_ENOBUFS, &ret, sizeof(int));
while (1) {
ret = mnl_socket_recvfrom(config.nl, buf, buf_size);
if (ret == -1) {
perror("mnl_socket_recvfrom");
goto die_buf;
}
ret = mnl_cb_run(buf, ret, 0, config.portid, queue_cb, NULL);
if (ret < 0) {
perror("mnl_cb_run");
// goto die_buf;
}
}
printf("%d\n", config.queue_num);
errno = 0;
free(buf);
close_socket();
return 0;
die_buf:
free(buf);
die_sock:
close_raw_socket();
close_socket();
exit(EXIT_FAILURE);
}