pktanon-master/ 0000755 0000000 0000000 00000000000 12701423271 012516 5 ustar root root pktanon-master/bootstrap 0000755 0000000 0000000 00000000033 12701423271 014455 0 ustar root root #! /bin/sh
autoreconf -i
pktanon-master/profiles/ 0000755 0000000 0000000 00000000000 12701423271 014341 5 ustar root root pktanon-master/profiles/profile.xml 0000644 0000000 0000000 00000006037 12701423271 016531 0 ustar root root
pktanon-master/profiles/profile-identity.xml 0000644 0000000 0000000 00000005541 12701423271 020357 0 ustar root root
pktanon-master/profiles/sample.pcap 0000644 0000000 0000000 00000001746 12701423271 016477 0 ustar root root ò &Rc * * 'FUǦ Ǧ 2R# N N # xфN` : zN # 8@ zNh9S J J PV PV0? E <@ @ ! уm r
h9S>
< < PV0? PV E , 7; g6Om`;B h9S>
6 6 PV PV0? E (@ @ 4 уmg6OPr S?$ b b PV PV0? E T@ @J ,) S +$ !"#$%&'()*+,-./01234567S b b PV0? PV E T ǭ ,) S +$ !"#$%&'()*+,-./01234567C"S?` 33 pZ.x` 'W l pIM-SEARCH * HTTP/1.1
Host:[FF02::C]:1900
ST:urn:Microsoft Windows Peer Name Resolution Protocol: V4:IPV6:LinkLocal
Man:"ssdp:discover"
MX:3
D"S+[
v v 33 @U9:n @: BU9: Mb@H, )2 @U9: @ ' : * pktanon-master/tests/ 0000755 0000000 0000000 00000000000 12701423271 013660 5 ustar root root pktanon-master/tests/transformations/ 0000755 0000000 0000000 00000000000 12701423271 017111 5 ustar root root pktanon-master/tests/transformations/ip6/ 0000755 0000000 0000000 00000000000 12701423271 017607 5 ustar root root pktanon-master/tests/transformations/ip6/tcp_checksum.xml 0000644 0000000 0000000 00000002423 12701423271 023002 0 ustar root root
pktanon-master/tests/transformations/ip6/mix.xml 0000644 0000000 0000000 00000001612 12701423271 021126 0 ustar root root
pktanon-master/tests/transformations/ip6/udp_checksum.xml 0000644 0000000 0000000 00000002722 12701423271 023006 0 ustar root root
pktanon-master/tests/transformations/ip6/ip6.exp 0000644 0000000 0000000 00000000702 12701423271 021022 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "IPv6"
if { ![exec_pktanon mix.xml ip6.pcap] } { break; }
test_field "ipv6.version" 6
test_field "ipv6.class" 0x00000015
test_field "ipv6.flow" 0x00081818
test_field "ipv6.plen" 0
test_field "ipv6.nxt" 58
test_field "ipv6.hlim" 5
test_field "ipv6.src" "abab:abab:abab:abab:abab:abab:abab:abab"
test_field "ipv6.dst" "cdcd:cdcd:cdcd:cdcd:cdcd:cdcd:cdcd:cdcd"
pktanon-master/tests/transformations/ip6/iden.xml 0000644 0000000 0000000 00000001447 12701423271 021256 0 ustar root root
pktanon-master/tests/transformations/ip6/ip6_tcp.pcap 0000644 0000000 0000000 00000002726 12701423271 022027 0 ustar root root ò E"S
'FU@U9:` x5
* +RO{ъNS P[ /S$ p[x/#c"K`MdfBkĒQ$-p ^O^kC w yln]pD=N CN/T{5O'"rTLBV~
E5ہ $˫Xk
lC2E%J bG#F ?:ca9P!Kivzy )b(D@T='ݲcVmmg^!GAkM^W}'6 sr>5GiH (F1,Io dY=l !9Ũ¤Ir#S?ˇE,u@ LTKԸVR&#ڪcB ?N2g>(vB^ak@,|wP-٥ 5 vOޥ ԅC T2 B UD6**u6:vƟ;\`vH
pxc vзGxd : MLt\8x@
-i j>3=գ,]䥾w^ o%Tt^5"0,xt # u.L5\Pn5藛df±=d[{pMuErH*{Sm o`qҧks8Yy1 IaRu ^PsnCQo ;³=0Cio]kRO隃&M}O
pktanon-master/tests/transformations/ethernet/ethernet.pcap 0000644 0000000 0000000 00000000122 12701423271 023405 0 ustar root root ò &Rc * * 'FUǦ (2
pktanon-master/tests/transformations/ethernet/iden.xml 0000644 0000000 0000000 00000000672 12701423271 022375 0 ustar root root
pktanon-master/tests/transformations/icmp6/ 0000755 0000000 0000000 00000000000 12701423271 020127 5 ustar root root pktanon-master/tests/transformations/icmp6/icmp_na_iden.exp 0000644 0000000 0000000 00000000670 12701423271 023255 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ICMP6-NA-IDEN"
if { ![exec_pktanon iden_na.xml icmp6_na.pcap] } { break; }
test_field "icmpv6.type" 136
test_field "icmpv6.code" 0
test_field "icmpv6.checksum" "0x78fd"
test_checksum_r "icmpv6"
test_field "icmpv6.nd.na.flag" "40:00:00:00"
test_field "icmpv6.nd.na.target_address" "fe80::7ae7:d1ff:fe84:4e06"
warning "what to do with RSO flags?"
pktanon-master/tests/transformations/icmp6/icmp_ns_iden.exp 0000644 0000000 0000000 00000000634 12701423271 023277 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ICMP6-NS-IDEN"
if { ![exec_pktanon iden_ns.xml icmp6_ns.pcap] } { break; }
test_field "icmpv6.type" 135
test_field "icmpv6.code" 0
test_field "icmpv6.checksum" "0xb0fa"
test_checksum_r "icmpv6"
test_field "icmpv6.reserved" "00:00:00:00"
test_field "icmpv6.nd.ns.target_address" "2a00:1398:2:4005:102a:fc8b:6d76:bb6e"
pktanon-master/tests/transformations/icmp6/icmp6_ns.pcap 0000644 0000000 0000000 00000000176 12701423271 022516 0 ustar root root ò 2RN V V 33vn 0Hā:` : 0Hā: vn v * @*mvn 0Hā: pktanon-master/tests/transformations/icmp6/mix_ns.xml 0000644 0000000 0000000 00000002043 12701423271 022145 0 ustar root root
pktanon-master/tests/transformations/icmp6/icmp_ns.exp 0000644 0000000 0000000 00000000625 12701423271 022300 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ICMP6-NS"
if { ![exec_pktanon mix_ns.xml icmp6_ns.pcap] } { break; }
test_field "icmpv6.type" 135
test_field "icmpv6.code" 0
test_field "icmpv6.checksum" "0xb14a"
test_checksum_r "icmpv6"
test_field "icmpv6.reserved" "00:00:00:00"
test_field "icmpv6.nd.ns.target_address" "2a00:1398:2:4005:102a:fc8b:6d76:bb6e"
pktanon-master/tests/transformations/icmp6/icmp_na.exp 0000644 0000000 0000000 00000000662 12701423271 022257 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ICMP6-NA"
if { ![exec_pktanon mix_na.xml icmp6_na.pcap] } { break; }
test_field "icmpv6.type" 136
test_field "icmpv6.code" 0
test_field "icmpv6.checksum" "0x78fd"
test_checksum_r "icmpv6"
test_field "icmpv6.nd.na.flag" "40:00:00:00"
test_field "icmpv6.nd.na.target_address" "fe80::7ae7:d1ff:fe84:4e06"
warning "what to do with RSO flags?"
pktanon-master/tests/transformations/icmp6/icmp6_na.pcap 0000644 0000000 0000000 00000000166 12701423271 022473 0 ustar root root ò 2R# N N # xфN` : zN # 8@ zN pktanon-master/tests/transformations/icmp6/iden_ns.xml 0000644 0000000 0000000 00000002044 12701423271 022270 0 ustar root root
pktanon-master/tests/transformations/icmp6/mix_na.xml 0000644 0000000 0000000 00000002050 12701423271 022121 0 ustar root root
pktanon-master/tests/transformations/icmp6/iden_na.xml 0000644 0000000 0000000 00000002044 12701423271 022246 0 ustar root root
pktanon-master/tests/transformations/arp/ 0000755 0000000 0000000 00000000000 12701423271 017673 5 ustar root root pktanon-master/tests/transformations/arp/arp_iden.exp 0000644 0000000 0000000 00000000771 12701423271 022177 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ARP-IDEN"
if { ![exec_pktanon iden.xml arp.pcap] } { break; }
test_field "arp.hw.type" 1
test_field "arp.proto.type" 0x0800
test_field "arp.hw.size" 6
test_field "arp.proto.size" 4
test_field "arp.opcode" 1
test_field "arp.src.hw_mac" "9c:c7:a6:d0:eb:f9"
test_field "arp.src.proto_ipv4" "192.168.178.1"
test_field "arp.dst.hw_mac" "00:00:00:00:00:00"
test_field "arp.dst.proto_ipv4" "192.168.178.20"
pktanon-master/tests/transformations/arp/mix.xml 0000644 0000000 0000000 00000002057 12701423271 021216 0 ustar root root
pktanon-master/tests/transformations/arp/arp.exp 0000644 0000000 0000000 00000000753 12701423271 021200 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ARP"
if { ![exec_pktanon mix.xml arp.pcap] } { break; }
test_field "arp.hw.type" 1
test_field "arp.proto.type" 0x0800
test_field "arp.hw.size" 6
test_field "arp.proto.size" 4
test_field "arp.opcode" 3855
test_field "arp.src.hw_mac" "f7:28:b2:8a:32:13"
test_field "arp.src.proto_ipv4" "192.168.0.0"
test_field "arp.dst.hw_mac" "ff:ff:ff:ff:ff:ff"
test_field "arp.dst.proto_ipv4" "192.168.10.10"
pktanon-master/tests/transformations/arp/arp.pcap 0000644 0000000 0000000 00000000122 12701423271 021315 0 ustar root root ò &Rc * * 'FUǦ Ǧ pktanon-master/tests/transformations/arp/iden.xml 0000644 0000000 0000000 00000001707 12701423271 021341 0 ustar root root
pktanon-master/tests/transformations/icmp/ 0000755 0000000 0000000 00000000000 12701423271 020041 5 ustar root root pktanon-master/tests/transformations/icmp/icmp.exp 0000644 0000000 0000000 00000000653 12701423271 021513 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ICMP"
if { ![exec_pktanon mix.xml icmp_echo_repl.pcap] } { break; }
test_field "icmp.type" 0
test_field "icmp.code" 171
test_field "icmp.checksum" "0x0359"
# test_checksum "icmp"
if { $verbose > 0 } { puts "\nThese 2 fields shoul be transformed by 'rest' anon" }
test_field "icmp.ident" "65021,65021"
test_field "icmp.seq" "65021"
pktanon-master/tests/transformations/icmp/mix.xml 0000644 0000000 0000000 00000002223 12701423271 021357 0 ustar root root
pktanon-master/tests/transformations/icmp/icmp_echo_req.pcap 0000644 0000000 0000000 00000000212 12701423271 023476 0 ustar root root ò S?$ b b PV PV0? E T@ @J ,) S +$ !"#$%&'()*+,-./01234567 pktanon-master/tests/transformations/icmp/iden.xml 0000644 0000000 0000000 00000002156 12701423271 021506 0 ustar root root
pktanon-master/tests/transformations/icmp/icmp_iden.exp 0000644 0000000 0000000 00000000674 12701423271 022515 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "ICMP-IDEN"
if { ![exec_pktanon iden.xml icmp_echo_req.pcap] } { break; }
test_field "icmp.type" 8
test_field "icmp.code" 0
test_field "icmp.checksum" 0xce41
vputs "\nThese 2 fields shoul be transformed by 'rest' anon"
test_field "icmp.ident" "10685,48425"
# expect ONE at the beginning of the line TODO: end of line
test_field "icmp.seq" "^1"
pktanon-master/tests/transformations/icmp/icmp_echo_repl.pcap 0000644 0000000 0000000 00000000212 12701423271 023651 0 ustar root root ò S b b PV0? PV E T ǭ ,) S +$ !"#$%&'()*+,-./01234567 pktanon-master/tests/transformations/udp/ 0000755 0000000 0000000 00000000000 12701423271 017701 5 ustar root root pktanon-master/tests/transformations/udp/mix.xml 0000644 0000000 0000000 00000002154 12701423271 021222 0 ustar root root
pktanon-master/tests/transformations/udp/udp.exp 0000644 0000000 0000000 00000000450 12701423271 021206 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "UDP"
if { ![exec_pktanon mix.xml udp.pcap] } { break; }
test_field "udp.srcport" 43690
test_field "udp.dstport" 48059
test_field "udp.length" 8
test_field "udp.checksum" "0x19a4"
test_checksum "udp"
pktanon-master/tests/transformations/udp/udp_iden.exp 0000644 0000000 0000000 00000000453 12701423271 022210 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "UDP-IDEN"
if { ![exec_pktanon iden.xml udp.pcap] } { break; }
test_field "udp.srcport" 53
test_field "udp.dstport" 45469
test_field "udp.length" 8
test_field "udp.checksum" "0xce37"
test_checksum "udp"
pktanon-master/tests/transformations/udp/udp.pcap 0000644 0000000 0000000 00000000322 12701423271 021333 0 ustar root root ò i9S PV0? PV E š 5 Q wwwgooglecom Eh E Eg Ej Ei Ec pktanon-master/tests/transformations/udp/iden.xml 0000644 0000000 0000000 00000002112 12701423271 021336 0 ustar root root
pktanon-master/tests/transformations/ip/ 0000755 0000000 0000000 00000000000 12701423271 017521 5 ustar root root pktanon-master/tests/transformations/ip/ip.exp 0000644 0000000 0000000 00000001060 12701423271 020644 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "IP"
if { ![exec_pktanon mix.xml ip.pcap] } { break; }
test_field "ip.version" 4
test_field "ip.hdr_len" 20
test_field "ip.dsfield" 0
test_field "ip.len" 20
test_field "ip.id" 0x0101
test_field "ip.flags" 0x07
test_field "ip.frag_offset" 0
test_field "ip.ttl" 2
test_field "ip.proto" 6
test_field "ip.checksum" 0xd7e3
test_checksum "ip"
test_field "ip.src" "240.240.240.240"
test_field "ip.dst" "15.15.15.15"
warning "TODO: flags are not transformed correctly"
pktanon-master/tests/transformations/ip/ip_iden.exp 0000644 0000000 0000000 00000001005 12701423271 021642 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "IP-IDEN"
if { ![exec_pktanon iden.xml ip.pcap] } { break; }
test_field "ip.version" 4
test_field "ip.hdr_len" 20
test_field "ip.dsfield" 0
test_field "ip.len" 20
test_field "ip.id" 0x0edf
test_field "ip.flags" 0x02
test_field "ip.frag_offset" 0
test_field "ip.ttl" 64
test_field "ip.proto" 6
test_field "ip.checksum" 0x1d49
test_checksum "ip"
test_field "ip.src" "192.168.127.128"
test_field "ip.dst" "173.194.32.209"
pktanon-master/tests/transformations/ip/mix.xml 0000644 0000000 0000000 00000002032 12701423271 021035 0 ustar root root
pktanon-master/tests/transformations/ip/ip.pcap 0000644 0000000 0000000 00000000162 12701423271 020775 0 ustar root root ò h9S J J PV PV0? E <@ @ ! уm r
pktanon-master/tests/transformations/ip/iden.xml 0000644 0000000 0000000 00000001661 12701423271 021166 0 ustar root root
pktanon-master/tests/transformations/tcp/ 0000755 0000000 0000000 00000000000 12701423271 017677 5 ustar root root pktanon-master/tests/transformations/tcp/tcp_syn.pcap 0000644 0000000 0000000 00000000162 12701423271 022222 0 ustar root root ò h9S J J PV PV0? E <@ @ ! уm r
pktanon-master/tests/transformations/tcp/tcp.exp 0000644 0000000 0000000 00000000653 12701423271 021207 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "TCP"
if { ![exec_pktanon mix.xml tcp.pcap] } { break; }
test_field "tcp.srcport" 257
test_field "tcp.dstport" 514
test_field "tcp.seq" 50529027
test_field "tcp.ack" 67372036
test_field "tcp.hdr_len" 20
test_field "tcp.flags" 0x0018
test_field "tcp.window_size_value" 1285
test_field "tcp.checksum" 0x8afa
test_checksum "tcp" pktanon-master/tests/transformations/tcp/tcp_ack.pcap 0000644 0000000 0000000 00000000136 12701423271 022150 0 ustar root root ò h9S>
6 6 PV PV0? E (@ @ 4 уmg6OPr pktanon-master/tests/transformations/tcp/mix.xml 0000644 0000000 0000000 00000002743 12701423271 021224 0 ustar root root
pktanon-master/tests/transformations/tcp/tcp_syn_ack.pcap 0000644 0000000 0000000 00000000144 12701423271 023040 0 ustar root root ò h9S>
< < PV0? PV E , 7; g6Om`;B pktanon-master/tests/transformations/tcp/iden.xml 0000644 0000000 0000000 00000002574 12701423271 021350 0 ustar root root
pktanon-master/tests/transformations/tcp/tcp_iden.exp 0000644 0000000 0000000 00000000671 12701423271 022206 0 ustar root root source [file join [file dirname [info script]] ../../lib/transftestlib.exp]
set test "TCP-IDEN"
if { ![exec_pktanon iden.xml tcp.pcap] } { break; }
test_field "tcp.srcport" 33777
test_field "tcp.dstport" 443
test_field "tcp.seq" 2439873758
test_field "tcp.ack" 1731612665
test_field "tcp.hdr_len" 20
test_field "tcp.flags" 0x0018
test_field "tcp.window_size_value" 29200
test_field "tcp.checksum" 0xdbd7
test_checksum "tcp"
pktanon-master/tests/transformations/tcp/tcp.pcap 0000644 0000000 0000000 00000000735 12701423271 021337 0 ustar root root ò h9S@
PV PV0? E @ @ уmg6OPrV z vS9hze@q23K$p|es)X2
: $(+ °EJjTI d2H'0]s-Ӽ H
9 8 5 E D 3 2 A /
www.google.com
# 8ĉlGםV<*qFNV%P1#L++WhjjKQPJ|Bɐ9^'HZC 쭸".yyk<<QO#Zţ!d^iqćA0K6nֈ'ux&\LI.Ow Fא3t pktanon-master/tests/anonprimitives/ 0000755 0000000 0000000 00000000000 12701423271 016727 5 ustar root root pktanon-master/tests/anonprimitives/chainstest.exp 0000644 0000000 0000000 00000002051 12701423271 021610 0 ustar root root set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/anontestlib.exp"]
set test [info script]
vputs "\n>>> AnonBroadcastHandler/AnonConstOverwrite ========================================\n"
set params {"value" "0x2b"}
set anons {"AnonBroadcastHandler" "AnonConstOverwrite"}
anon_chain_test $params $anons "-----" "+++++"
# # TODO
set params {"value" "0x2b" "hex_output" "1"}
anon_chain_test $params $anons "#ffffffffff" "ffffffffff"
vputs "\n>>> AnonConstOverwrite/AnonShorten ========================================\n"
set params {"value" "0x2b" "newlen" "3"}
set anons {"AnonConstOverwrite" "AnonShorten"}
anon_chain_test $params $anons "-----" "+++"
set anons {"AnonShorten" "AnonConstOverwrite"}
anon_chain_test $params $anons "-----" "+++"
vputs "\n>>> several primitives ========================================\n"
set params {"value" "0x2b" "newlen" "3"}
set anons {"AnonBroadcastHandler" "AnonBroadcastHandler" "AnonBroadcastHandler" "AnonConstOverwrite" "AnonShorten"}
anon_chain_test $params $anons "-----" "+++" pktanon-master/tests/anonprimitives/AnonTester.h 0000644 0000000 0000000 00000001352 12701423271 021163 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef ANONTESTER_H
#define ANONTESTER_H
// #include
#include
#include
using namespace pktanon;
class AnonTester
{
public:
AnonTester();
~AnonTester();
void addParam(std::string name, std::string value);
void addAnon ( std::string anon_class );
void eval(std::string val);
private:
Params params;
AnonPrimitive* anon;
AnonPrimitive* last_anon;
bool hex_output;
};
#endif // ANONTESTER_H
pktanon-master/tests/anonprimitives/basictest.exp 0000644 0000000 0000000 00000005230 12701423271 021426 0 ustar root root set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/anontestlib.exp"]
set test [info script]
vputs "\n>>> AnonConstOverwrite ========================================\n"
#0x3a - ascii value for ':'
set params {"value" "0x3a"}
anon_value_test "AnonConstOverwrite" $params "12345" ":::::"
#0x2b - ascii value for '+'
set params {"value" "0x2b"}
anon_value_test "AnonConstOverwrite" $params "12345678" "++++++++"
vputs "\n>>> AnonConstOverwriteRange ========================================\n"
set params {"value" "0x3a" "range-begin" "0" "range-length" "9"}
anon_value_test "AnonConstOverwriteRange" $params "123456789" ":::::::::"
set params {"value" "0x3a" "range-begin" "5" "range-length" "9"}
anon_value_test "AnonConstOverwriteRange" $params "123456789" "12345::::"
set params {"value" "0x3a" "range-begin" "0" "range-length" "5"}
anon_value_test "AnonConstOverwriteRange" $params "123456789" ":::::6789"
set params {"value" "0x3a" "range-begin" "5" "range-length" "2"}
anon_value_test "AnonConstOverwriteRange" $params "123456789" "12345::89"
vputs "\n>>> AnonHashSha1/Sha256 ========================================\n"
set params {"hex_output" "1"}
# echo -n "value" | openssl dgst -sha1
# (stdin)= f32b67c7e2(6342af42efabc674d441dca0a281c)
anon_value_test "AnonHashSha1" $params "value" "f32b67c7e2"
set big_string "aaaa_aaaa_aaaa_aaaa_aaaa_aaaa_aaaa_aaaa_"
# echo -n $big_string | openssl dgst -sha1
# (stdin)= 48420d4cbbf021d3517bb8aae0dca45be28d344a
anon_value_test "AnonHashSha1" $params $big_string "48420d4cbbf021d3517bb8aae0dca45be28d344a48420d4cbbf021d3517bb8aae0dca45be28d344a"
# TODO test wrap hash around on values not multiple of 20
# echo -n "value" | openssl dgst -sha256
# (stdin)= cd42404d52(ad55ccfa9aca4adc828aa5800ad9d385a0671fbcbf724118320619)
anon_value_test "AnonHashSha256" $params "value" "cd42404d52"
vputs "\n>>> AnonIdentity ========================================\n"
set params {"hex_output" "0"}
anon_value_test "AnonIdentity" $params "val" "val"
anon_value_test "AnonIdentity" $params "bignonceval123" "bignonceval123"
vputs "\n>>> AnonShorten ========================================\n"
set params {"newlen" "3"}
anon_value_test "AnonShorten" $params "value" "val"
set params {"newlen" "0"}
anon_value_test "AnonShorten" $params "value" ""
# they seem to be impossible to test without whole pktanon, the transformations are not set
# vputs "\n>>> AnonKnownProtocolHandler ========================================\n"
# anon_value_test "AnonKnownProtocolHandler" $params "123" "123"
# vputs "\n>>> AnonKnownEthertypeHandler ========================================\n"
# anon_value_test "AnonKnownEthertypeHandler" $params "123" "123" pktanon-master/tests/anonprimitives/AnonTester.cpp 0000644 0000000 0000000 00000007424 12701423271 021524 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonTester.h"
#include
#include
#include
#include
#include
#include
#include
using namespace pktanon;
void hex_dump ( char *buff, int len )
{
for ( unsigned j = 0; j < len; j++ )
{
printf ( "%02hhx", buff[j] );
// std::cout << std::hex << std::setw(2) << dst_buff[j];
}
}
int ch2dec ( char c )
{
switch ( c )
{
case 'a' :
return 10;
case 'b' :
return 11;
case 'c' :
return 12;
case 'd' :
return 13;
case 'e' :
return 14;
case 'f' :
return 15;
default:
return atoi ( &c );
}
}
AnonTester::~AnonTester() { }
AnonTester::AnonTester() : anon ( nullptr ), params(), hex_output ( 0 ) { }
void AnonTester::addParam ( string name, string value )
{
if ( name.compare ( "hex_output" ) == 0 )
{
hex_output = ( value.at ( 0 ) == '1' );
}
else
{
params.add_param ( std::move ( name ), std::move ( value ) );
}
}
void AnonTester::addAnon ( std::string anon_class )
{
AnonPrimitive* prim = AnonFactory::create_anon ( anon_class, params );
if ( anon == nullptr )
{
// TRACEV(anon_class);
anon = prim;
last_anon = prim;
}
else
{
// TRACEV(anon_class);
last_anon->setNext ( prim );
last_anon = prim;
}
}
void AnonTester::eval ( string val )
{
auto src_buff = const_cast ( val.data() );
auto src_len = val.size();
if ( val.at ( 0 ) == '#' ) // the rest of the string should be interpreted as hex value
{
src_len = ( val.size()-1 ) /2;
src_buff = new char[src_len];
for ( int j = 1; j < val.size(); j+=2 )
{
int index = ( j-1 ) /2;
int ch_val = ch2dec ( val.at ( j ) ) *16 + ch2dec ( val.at ( j+1 ) );
src_buff[index] = ( char ) ch_val;
}
// hex_dump ( src_buff, src_len );
}
char dst_buff[src_len +1];
memset ( &dst_buff, '\0', src_len +1 );
auto result_len = anon->anonimyze ( src_buff, dst_buff, src_len );
// TRACE(result_len);
if ( hex_output )
{
std::cout << "result = {";
hex_dump ( dst_buff, result_len );
std::cout << std::dec << "}" << std::endl;
}
else
{
auto dst_str = std::string(dst_buff).substr(0,result_len);
_plg_info ( "result = {" << std::hex << dst_str << "}" );
}
}
int main ( int argc, char* argv[] )
{
AnonTester tester;
// _plg_info ( "=== AnonTester ===" );
// _plg_info ( "a ; p ; v ;q" );
std::string command;
std::string anon_class;
std::string param_name;
std::string param_value;
std::string buffer;
while ( 1 )
{
_plg_info ( "enter command:" );
std::cin >> command;
// TRACEV ( command );
switch ( command.at ( 0 ) )
{
case 'a':
std::cin >> anon_class;
// TRACEV ( anon_class );
tester.addAnon ( anon_class );
break;
case 'p':
std::cin >> param_name;
std::cin >> param_value;
// TRACEV(param_name);
// TRACEV(param_value);
tester.addParam ( param_name, param_value );
break;
case 'v':
std::cin >> buffer;
// TRACEV ( buffer );
tester.eval ( buffer );
break;
case 'q':
return 0;
default:
_plg_error ( "unnown command, use a, p, v, or q" );
}
}
// std::string anon;
// std::string buffer;
//
// _plg_info ( "Enter Anon Class:" );
// std::cin >> anon;
//
//
// _plg_info ( "Enter Anon Value:" );
// std::cin >> buffer;
//
// TRACEV ( anon )
// TRACEV ( buffer )
}
pktanon-master/tests/pktanon-runtime/ 0000755 0000000 0000000 00000000000 12701423271 017013 5 ustar root root pktanon-master/tests/pktanon-runtime/libpcap_live__dump.exp 0000644 0000000 0000000 00000003745 12701423271 023357 0 ustar root root #
# test pktanon with live capture by libpcap
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
# test sudo working: ######################################################
set status [test_sudo_nopwd]
if { $status != 0 } {
unsupported "$test: cannot execute sudo without passwords (status = $status)"
break
}
# spawn pktanon: ###########################################################
spawn sudo $PKTANON -c $anon_profile -i lo -U $out_file
expect {
initialized {
match_io_logs "libpcap"
}
eof {fail "$test pktanon failed to initialize"; break;}
timeout {fail "$test pktanon failed to initialize"; break;}
}
set pktanon_spawn_id $spawn_id
# send packets to lo using tcpreplay: ######################################
log_user 0
spawn sudo tcpreplay -i lo -t -l 1 $trace_file
expect {
-re "Successful packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {
set pkts_sent unknown
unsupported "$test - failed to send packets with tcpreplay"
}
}
# wait some time and terminate pktanon: ##########################################
sleep 1
log_user $log_user_original
set spawn_id $pktanon_spawn_id
send \x03
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_processed [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed"}
timeout {fail "$test pktanon failed"}
}
# count number of frames in result: ##########################################
set pkts_rcvd [count_frames $out_file]
# test that pktanon received all the packets: ##########################################
if { $verbose > 0 } {
puts "\n\nnumber of pkts sent = $pkts_sent"
puts "number of pkts rcved = $pkts_rcvd"
}
if { $pkts_sent == $pkts_rcvd} {pass $test} {
fail "$test: expected $pkts_sent packets, actual $pkts_rcvd packets"
}
# compare some statistics in trace.pcap and out.pcap -> ensure that fields are indeed copied
compare_stats $trace_file $out_file pktanon-master/tests/pktanon-runtime/profile.xml 0000644 0000000 0000000 00000005542 12701423271 021203 0 ustar root root
pktanon-master/tests/pktanon-runtime/libpcap_dump__inject.exp 0000644 0000000 0000000 00000002241 12701423271 023662 0 ustar root root set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
### file - libpcap-inct ############################################
# start tshark
spawn -noecho sudo tshark -i lo -q -z io,stat,0
expect "Loopback"
# doesn't work without it
sleep 2
set tshark_spawn_id $spawn_id
# start pktanon
spawn sudo $PKTANON -c $anon_profile -n lo $trace_file
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed to initialize"; break;}
timeout {fail "$test pktanon failed to initialize"; break;}
}
set spawn_id $tshark_spawn_id
# doesn't work without it
sleep 2
send \x03
send \x03
expect eof
set buff $expect_out(buffer)
set found [regexp -line -lineanchor {^\|\s0\.000[ <>0-9.]+\|\s*(\d+)} $buff match pkts_captured ]
if { $found != 1} { fail $test }
set pkts_in_trace_file [count_frames $trace_file]
if { $pkts_sent != $pkts_in_trace_file } { fail $test "pktanon sent less files that there are in $trace_file"}
if { $pkts_captured != $pkts_in_trace_file } { fail $test "less packets were captured on lo than in $trace_file"}
pktanon-master/tests/pktanon-runtime/libpcap_live_filter.exp.todo 0000644 0000000 0000000 00000003217 12701423271 024476 0 ustar root root set test "test libpcap live input"
puts "warning: this test requires root privileges"
source lib/tshark_utils.exp
log_user 0
if { $verbose >= 0 } { log_user 1 }
if { $verbose > 0 } { puts "================== $test =================="}
# test sudo working: ######################################################
try {
set results [exec sudo -nv ]
set status 0
} trap CHILDSTATUS {results options} {
set status [lindex [dict get $options -errorcode] 2]
}
if {$status != 0} {fail "$test: cannot execute sudo pktanon"}
# spawn pktanon: ###########################################################
spawn sudo ../../src/pktanon -i lo -e "not arp" ../out.pcap
expect {
initialized { }
eof {fail $test; exit 1}
timeout { fail $test }
}
set spawn_pktanon $spawn_id
# send packets to lo using tcpreplay: ######################################
spawn sudo tcpreplay -i lo -t -l 1 trace.pcap
expect {
-re "Successful packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait }
eof { set pkts_sent unknown}
}
# wait some time and kill pktanon: ##########################################
sleep 1
exec sudo killall pktanon
# count number of frames in result and number of frames matching filter in original file:
set pkts_matched [count_frames trace.pcap "not arp"]
set pkts_rcvd [count_frames ../out.pcap]
# test that pktanon received all the packets: ##########################################
if { $verbose > 0 } {
puts "\n\nnumber of pkts sent = $pkts_matched"
puts "number of pkts rcved = $pkts_rcvd"
}
if { $pkts_matched == $pkts_rcvd} {pass $test} {
fail "$test: expected $pkts_matched packets, actual $pkts_rcvd packets"
} pktanon-master/tests/pktanon-runtime/gzip_pipe.sh 0000755 0000000 0000000 00000000051 12701423271 021334 0 ustar root root #!/bin/bash
zcat trace.pcap.gz | $1 - $2
pktanon-master/tests/pktanon-runtime/libpcap_dump.exp.todo 0000644 0000000 0000000 00000000565 12701423271 023142 0 ustar root root set test "test libpcap-file-io"
set pktopts {-c profile_iden.xml -l trace.pcap ../out.pcap}
source common.exp
expect {
"total packets: 100" {
# expect {
# -re "elapsed time.us.: (\[0-9\]+)" { set profile_iden [expr { $expect_out(1,string) }] }
# }
wait
fail " $test; >> i have no idea how to test if it is libpcap "
}
eof { fail $test}
} pktanon-master/tests/pktanon-runtime/libpcap_dump__dump.exp 0000644 0000000 0000000 00000003514 12701423271 023357 0 ustar root root #
# test basic functions of LibpcapLoop on file-file
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
## test1:
## run pktanon with default profile
spawn $PKTANON -l -c $anon_profile $trace_file $out_file
expect {
"complete" {
match_io_logs "libpcap"
expect eof
}
eof {
fail "$test: failed running pktanon with default profile"
break;
}
}
## read number of packets and time
set packets_iden 0
set time_iden 0
regexp {processed packets:\s*(\d+)} $expect_out(buffer) match packets_iden;
regexp {\s(\d+)us} $expect_out(buffer) match time_iden;
## test that identity works
compare_stats $trace_file $out_file
## test2:
## run pktanon with non-default profile
spawn $PKTANON -l -c $anon_profile_mix $trace_file $out_file
expect {
"complete" {
match_io_logs "libpcap"
expect eof
}
eof {
fail "$test: failed running pktanon with non-default profile"
break;
}
}
## read number of packets and time
set packets_mix 0
set time_mix 0
regexp {processed packets:\s*(\d+)} $expect_out(buffer) match packets_mix;
regexp {\s(\d+)us} $expect_out(buffer) match time_mix;
set expected_pkts 100;
if {$verbose > 0} {
puts "\n"
puts "expected pkts: $expected_pkts"
puts "results:"
puts " \tiden\tmix"
puts "pkts: \t$packets_iden\t$packets_mix"
puts "time: \t$time_iden\t$time_mix"
puts "\n"
}
if {$packets_iden != $expected_pkts} { fail "$test - expected $expected_pkts, processed $packets_iden packets"; set test_passed 0;}
if {$packets_mix != $expected_pkts} { fail "$test - expected $expected_pkts, processed $packets_mix packets"; set test_passed 0;}
if {$time_mix <= $time_iden} { fail "$test - mixed profile shoud be slower than identity profile, actual times(us): iden=$time_iden,mix=$time_mix"; set test_passed 0;}
pktanon-master/tests/pktanon-runtime/raw_socket__ostream.exp 0000644 0000000 0000000 00000004323 12701423271 023565 0 ustar root root set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
# test sudo working: ######################################################
set status [test_sudo_nopwd]
if { $status != 0 } {
unsupported "$test: cannot execute sudo without passwords (status = $status)"
break
}
# spawn pktanon: ###########################################################
spawn sudo $PKTANON -c $anon_profile -i lo -r $out_file
expect {
initialized {
match_io_logs "socket-raw"
match_io_logs "ostream"
}
eof {fail "$test pktanon failed to initialize"; break;}
timeout {fail "$test pktanon failed to initialize"; break;}
}
set spawn_pktanon $spawn_id
# send packets to lo using tcpreplay: ######################################
log_user 0
spawn sudo tcpreplay -i lo -t -l 1 $trace_file
expect {
-re "Successful packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {
set pkts_sent unknown
unsupported "$test - failed to send packets with tcpreplay"
}
}
log_user $log_user_original
# wait some time and terminate pktanon: ##########################################
sleep 1
set spawn_id $spawn_pktanon
send \x03
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_processed [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed"}
timeout {fail "$test pktanon failed"}
}
# count number of frames in result: ##########################################
set pkts_rcvd [count_frames $out_file]
# test that pktanon received all the packets: ##########################################
if { $verbose > 0 } {
puts "\n\nnumber of pkts sent = $pkts_sent"
puts "number of pkts processed = $pkts_processed"
puts "number of pkts rcved = $pkts_rcvd"
}
if { $pkts_sent == $pkts_rcvd} {pass $test} {
fail "$test: expected $pkts_sent packets, actual $pkts_rcvd packets"
}
if { $pkts_sent == $pkts_processed} {pass $test} {
fail "$test: expected $pkts_sent processed packets packets, actual $pkts_processed packets"
}
### check that packets are filled with data
compare_stats $trace_file $out_file
### TODO packets are doubled
### TODO packets are not filled despite that they seem to be written normally pktanon-master/tests/pktanon-runtime/istream__ostream.exp 0000644 0000000 0000000 00000003612 12701423271 023070 0 ustar root root #
# test pktanon infile/outfile with std::io
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
## test1:
## run pktanon with default profile
spawn $PKTANON -c $anon_profile $trace_file $out_file
expect {
"complete" {
match_io_logs "istream"
match_io_logs "ostream"
expect eof
}
eof {
fail "$test: failed running pktanon with default profile"
break
}
}
## read number of packets and time
set packets_iden 0
set time_iden 0
regexp {processed packets:\s*(\d+)} $expect_out(buffer) match packets_iden;
regexp {\s(\d+)us} $expect_out(buffer) match time_iden;
## compare stats in trace file and output file
compare_stats $trace_file $out_file
## test2:
## run pktanon with non-default profile
spawn $PKTANON -c $anon_profile_mix $trace_file $out_file
expect {
"complete" {
match_io_logs "istream"
match_io_logs "ostream"
expect eof
}
eof {
fail "$test: failed running pktanon with non-default profile"
break;
}
}
## read number of packets and time
set packets_mix 0
set time_mix 0
regexp {processed packets:\s*(\d+)} $expect_out(buffer) match packets_mix;
regexp {\s(\d+)us} $expect_out(buffer) match time_mix;
set expected_pkts 100;
if {$verbose > 0} {
puts "\n"
puts "expected pkts: $expected_pkts"
puts "results:"
puts " \tiden\tmix"
puts "pkts: \t$packets_iden\t$packets_mix"
puts "time: \t$time_iden\t$time_mix"
puts "\n"
}
if {$packets_iden != $expected_pkts} { fail "$test - expected $expected_pkts, processed $packets_iden packets"; set test_passed 0;}
if {$packets_mix != $expected_pkts} { fail "$test - expected $expected_pkts, processed $packets_mix packets"; set test_passed 0;}
if {$time_mix <= $time_iden} { fail "$test - mixed profile shoud be slower than identity profile, actual times(us): iden=$time_iden,mix=$time_mix"; set test_passed 0;}
pktanon-master/tests/pktanon-runtime/libpcap_live__socket_output_udp.exp 0000644 0000000 0000000 00000004613 12701423271 026165 0 ustar root root #
# test libpcap-capture - udp-socket combination
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
set pkt_ifname lo
set port 8888
#### test pktanon listening to interface and sending output to udp socket
# start nmap in ipv6/udp mode
spawn -noecho ncat -6 -u -l $port
# spawn pktanon
spawn sudo $PKTANON -c $anon_profile -i $pkt_ifname -o ::1:$port -6 -u
expect {
initialized {
set pktanon_initialized 1
# match_io_logs "libpcap"
}
eof {fail "$test pktanon failed to initialize"; break;}
timeout {fail "$test pktanon failed to initialize"; break;}
}
set pktanon_spawn_id $spawn_id
log_user 0
# start tshark that counts frames
spawn -noecho sudo tshark -i lo -q -z io,stat,0
expect "Loopback"
# doesn't work without it
sleep 2
set tshark_spawn_id $spawn_id
# send trace_file on lo and count the packets sent
spawn sudo tcpreplay -i lo -t -l 1 $trace_file
expect {
-re "Successful packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {
set pkts_sent unknown
unsupported "$test - failed to send packets with tcpreplay"
}
}
# stop pktanon and count packets sent
log_user $log_user_original
set spawn_id $pktanon_spawn_id
send \x03
send \x03
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_processed [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed"; break; }
timeout {fail "$test pktanon failed"; break;}
}
log_user 0
set spawn_id $tshark_spawn_id
# doesn't work without it
sleep 2
send \x03
send \x03
expect eof
set pkts_captured [count_frames_in_output $expect_out(buffer)]
## for some reasons pktanon processes twice the number of pkts being sent
## and doesn't go into infinite loop
if { $verbose > 0} {
puts "\npkts sent = $pkts_sent"
puts "pkts processed = $pkts_processed"
puts "pkts captured = $pkts_captured"
}
if { $pkts_processed < $pkts_sent} { fail " pktanon didn't process enough packets"}
if { $pkts_captured < ($pkts_sent + $pkts_processed) } { fail " pktanon didn't sent enough packets on output interface"}
log_user $log_user_original
# TODO: this
# TODO: test with stdin,stdout and io pipes
# TODO: ipv6 forwarding header
# TODO: disallow libpcap-dump to not libpcap
# TODO: remove / move error-codes to pktanon / something so that there is no need to include something other than packetanon / error-codes
pktanon-master/tests/pktanon-runtime/console.exp 0000644 0000000 0000000 00000002004 12701423271 021167 0 ustar root root #
# small tests to test correct parsing of console options
#
proc expect_error_message {} {
global spawn_id
global test
expect {
"Error:" {
expect {
"initializing PktAnon" { fail "$test - pktanon should have exited" }
eof { pass $test }
}
}
eof {fail "$test - expected error message"}
}
}
#----------------------------------------------------
set test "test help message"
spawn $PKTANON -h
expect {
"Usage" {
expect {
"verbose" { pass "$test - help message"}
eof { fail "$test - expected --verbose help string"}
}
}
eof { fail "$test - expected pktanon help" }
}
#----------------------------------------------------
set test "test missing output file"
spawn $PKTANON infile
expect_error_message
#----------------------------------------------------
set test "test too many files"
spawn $PKTANON outfile
expect_error_message
#----------------------------------------------------
set test "snaplen NaN"
spawn $PKTANON -s abc infile outfile
expect_error_message pktanon-master/tests/pktanon-runtime/istream__socket_output_ip6_tcp.exp 0000644 0000000 0000000 00000003415 12701423271 025753 0 ustar root root #
# test for socket-output (test ip6/tcp output)
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
set port 8888
### ipv6 socket (ipv6, tcp) ############################################
# start nmap in ipv4/tcp mode
spawn ncat -6 -l $port
# start tshark
spawn -noecho sudo tshark -i lo -q -z io,stat,0,ip,ipv6,tcp,udp
expect "Loopback"
# doesn't work without it
sleep 2
set tshark_spawn_id $spawn_id
# start pktanon
spawn $PKTANON -c $anon_profile -o ::1:$port -6 $trace_file
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed"; break;}
timeout {fail "$test pktanon failed"; break;}
}
log_user 0
set spawn_id $tshark_spawn_id
# doesn't work without it
sleep 2
send \x03
send \x03
expect eof
set buff $expect_out(buffer)
set tshark_stats [count_stats_in_output $buff]
set ip_frames [lindex $tshark_stats 0]
set ip6_frames [lindex $tshark_stats 1]
set tcp_frames [lindex $tshark_stats 2]
set udp_frames [lindex $tshark_stats 3]
vputs "captured sent frames:"
vputs " stat ip4_frames: expected - none, result - $ip_frames"
vputs " stat ip6_frames: expected - some, result - $ip6_frames"
vputs " stat tcp_frames: expected - some, result - $tcp_frames"
vputs " stat udp_frames: expected - none, result - $udp_frames"
# puts "fc = $ip_frames"
# puts "fc = $ip6_frames"
# puts "fc = $tcp_frames"
# puts "fc = $udp_frames"
if {$ip_frames > 0} { fail "$test there should not be any ip4 frames"}
if {$ip6_frames <= 0} { fail "$test there should be ip6 frames"}
if {$tcp_frames <= 0} { fail "$test there should be tcp frames"}
if {$udp_frames > 0} { fail "$test there should not be any udp frames"}
log_user $log_user_original pktanon-master/tests/pktanon-runtime/istream__socket_output_ip6_udp.exp 0000644 0000000 0000000 00000003357 12701423271 025762 0 ustar root root #
# test for socket-output (test ip6/udp output)
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
set port 8888
### ipv6 socket (ipv6, tcp) ############################################
log_user 0
# start nmap in ipv4/tcp mode
spawn -noecho ncat -6 -u -l $port
# start tshark
spawn -noecho sudo tshark -i lo -q -z io,stat,0,ip,ipv6,tcp,udp
expect "Loopback"
# doesn't work without it
sleep 2
set tshark_spawn_id $spawn_id
log_user $log_user_original
# start pktanon
spawn $PKTANON -c $anon_profile -o ::1:$port -6 -u $trace_file
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed to initialize"; break;}
timeout {fail "$test pktanon failed to initialize"; break;}
}
log_user 0
set spawn_id $tshark_spawn_id
# doesn't work without it
sleep 2
send \x03
send \x03
expect eof
set buff $expect_out(buffer)
set tshark_stats [count_stats_in_output $buff]
set ip_frames [lindex $tshark_stats 0]
set ip6_frames [lindex $tshark_stats 1]
set tcp_frames [lindex $tshark_stats 2]
set udp_frames [lindex $tshark_stats 3]
vputs "\ncaptured sent frames:"
vputs " stat ip4_frames: expected - none, result - $ip_frames"
vputs " stat ip6_frames: expected - 100, result - $ip6_frames"
vputs " stat tcp_frames: expected - none, result - $tcp_frames"
vputs " stat udp_frames: expected - 100, result - $udp_frames"
if {$ip_frames > 0} { fail "$test there should be no ip frames"}
if {$ip6_frames != 100} { fail "$test there should be ipv6 frames"}
if {$tcp_frames > 0} { fail "$test there should be no frames"}
if {$udp_frames != 100} { fail "$test there should be udp frames"}
log_user $log_user_original pktanon-master/tests/pktanon-runtime/libpcap_live__inject.exp 0000644 0000000 0000000 00000003464 12701423271 023664 0 ustar root root #
# test libpcap-capture - libpcap-inject combination
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
### file - libpcap-life ############################################
# start tshark
spawn -noecho sudo tshark -i lo -q -z io,stat,0
expect "Loopback"
# doesn't work without it
sleep 2
set tshark_spawn_id $spawn_id
# start pktanon
spawn sudo $PKTANON -c $anon_profile -i lo -n lo $trace_file
set pktanon_spawn_id $spawn_id
# start tcpreplay, send trace_file on lo and count the packets sent
log_user 0
spawn sudo tcpreplay -i lo -t -l 1 $trace_file
expect {
-re "Successful packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {
set pkts_sent unknown
unsupported "$test - failed to send packets with tcpreplay"
}
}
# interrupt pktanon and count packets sent
sleep 0
log_user $log_user_original
set spawn_id $pktanon_spawn_id
send \x03
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_processed [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed"; break; }
timeout {fail "$test pktanon failed"; break;}
}
log_user 0
set spawn_id $tshark_spawn_id
# doesn't work without it
sleep 2
send \x03
send \x03
expect eof
set pkts_captured [count_frames_in_output $expect_out(buffer)]
## for some reasons pktanon processes twice the number of pkts being sent
## and doesn't go into infinite loop
if { $verbose > 0} {
puts "\npkts sent = $pkts_sent"
puts "pkts processed = $pkts_processed"
puts "pkts captured = $pkts_captured"
}
if { $pkts_processed < $pkts_sent} { fail " pktanon didn't process enough packets"}
if { $pkts_captured < ($pkts_sent + $pkts_processed) } { fail " pktanon didn't sent enough packets on output interface"}
log_user $log_user_original pktanon-master/tests/pktanon-runtime/iostreams_tshark_input.exp.todo 0000644 0000000 0000000 00000001663 12701423271 025304 0 ustar root root # #
# # TODO
# #
#
# set script_dir [file dirname [info script]]
# source [file join $script_dir "../lib/lib.exp"]
# # make check runs scripts from another directory, all file pathes are relative to $script_dir
# set curr_dir [pwd]
#
# cd $script_dir
#
# set_test [info script]
#
# ## test1:
# ## run pktanon with default profile
# set test_passed 1;
#
# spawn ./gzip_pipe.sh $PKTANON
# expect {
# "complete" {
# match_io_logs "istream"
# match_io_logs "ostream"
# expect eof
# }
# eof {
# set test_passed 0
# fail "$test: failed running pktanon with default profile"
# }
# }
#
# ## read number of packets and time
# set packets_iden 0
# set time_iden 0
#
# regexp {processed packets:\s*(\d+)} $expect_out(buffer) match packets_iden;
# regexp {\s(\d+)us} $expect_out(buffer) match time_iden;
#
# ## compare stats in trace file and output file
# compare_stats "trace.pcap" "../out.pcap"
#
# cd $curr_dir
pktanon-master/tests/pktanon-runtime/profile_mix.xml 0000644 0000000 0000000 00000006036 12701423271 022057 0 ustar root root
pktanon-master/tests/pktanon-runtime/istream_gzip_stdin__ostream.exp 0000644 0000000 0000000 00000001565 12701423271 025327 0 ustar root root #
# test std::io with pipe
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
set curr_dir [pwd]
cd $script_dir
## test pipe with compressed file as input
# compress trace.pcap
exec gzip -k -f trace.pcap
set test_passed 1;
spawn ./gzip_pipe.sh $PKTANON ../out.pcap
expect {
"complete" {
match_io_logs "istream"
match_io_logs "ostream"
expect eof
}
eof {
fail "$test: failed running pktanon with default profile"
cd $curr_dir
break;
}
}
## read number of packets and time
set packets_iden 0
set time_iden 0
regexp {processed packets:\s*(\d+)} $expect_out(buffer) match packets_iden;
regexp {\s(\d+)us} $expect_out(buffer) match time_iden;
## compare stats in trace file and output file
compare_stats trace.pcap ../out.pcap
exec rm trace.pcap.gz
cd $curr_dir
pktanon-master/tests/pktanon-runtime/trace.pcap 0000644 0000000 0000000 00000024313 12701423271 020761 0 ustar root root ò TW@ O O Ԛ u E A @u[ -Z'BC 32scc-wkit-clx-227-138.scc.kit.edu T~@ < < ܅>I ܅>I6 T@ < < @U9: @U9: T O O Ԛ u E A @11 -bBC 32scc-wkit-clx-227-138.scc.kit.edu T < < (G { (G {l T $wl8 E @ @..D\D\ ]<{"host_int": 2239754224, "version": [1, 8], "displayname": "", "port": 17500, "namespaces": [21212393, 49465841, 52918784, 131578347]} T $wl8 E @ @:.D\D\ 8{"host_int": 2239754224, "version": [1, 8], "displayname": "", "port": 17500, "namespaces": [21212393, 49465841, 52918784, 131578347]} T7` O O Ԛ u E At @ -kBC 32scc-wkit-clx-227-138.scc.kit.edu TF` < < d26 d26 TM` O O Ԛ u E A @5 -BC 32scc-wkit-clx-227-138.scc.kit.edu T : : Ԛ u E ,,V @`ڍ㊍! w=BJNB T : : ^ Ԛ u E , L9 ×! ;`BNJB T \ \ S.I E N < < 2" 2" TL < < |&QP |&QP T, @ @ ^ t E 2Z P wpad T @ @ } 2 <>@U9: >@U9: > T < < 1A 1A/ T < < 4Yw . RR HP AP station roamed T#L < < m6 m6 T6L < < |&QP |&QP T`m < < S S T : : H E , @ _! BJNB TI < < S.o"s S.o"s Ю TT < < `67{u `67{u Ti |#:( E @ @Yml gM-SEARCH * HTTP/1.1
HOST: 239.255.255.250:1900
MAN: "ssdp:discover"
MX: 1
ST: urn:schemas-upnp-org:device:ZonePlayer:1
X-RINCON-HOUSEHOLD: Sonos_0ocKxbf8RMclla3gcs7k1Regzr
T{ < < @U9: @U9: Tp=
O O Ԛ u E Asb @ -SBC 32scc-wkit-clx-227-138.scc.kit.edu TD O O Ԛ u E A @ B -7BC 32scc-wkit-clx-227-138.scc.kit.edu T 8 8 Qez Qez T < < Ĉ巡 . RR HP AP station connected T < < S.o"s S.o"s Ю T F F 33 `67{u` : Џ!] `67{u T O O Ԛ u E AT @"p -FyBC 32scc-wkit-clx-227-138.scc.kit.edu T9 \ \ 䔘 E N+ W[ :OW FHFAEBEECACACACACACACACACACACAAA T9 O O Ԛ u E Ab @M -{BC 32scc-wkit-clx-227-138.scc.kit.edu T9 |#:( E @ @Yml gM-SEARCH * HTTP/1.1
HOST: 239.255.255.250:1900
MAN: "ssdp:discover"
MX: 1
ST: urn:schemas-upnp-org:device:ZonePlayer:1
X-RINCON-HOUSEHOLD: Sonos_0ocKxbf8RMclla3gcs7k1Regzr
T8 < < @U9: @U9: I TY < < t/h:! t/h:!% TY < < 8<
df 8<
df@ TY O O Ԛ u E A; @QG -lBC 32scc-wkit-clx-227-138.scc.kit.edu Ta < < @U9: @U9: Tt V V 33:\
[T` :* 2ތ : R\ BU9:\
[T T @ @ } 2 <>@U9: >@U9: > T O O Ԛ u E A @* -nBC 32scc-wkit-clx-227-138.scc.kit.edu T < < 0 D 0 D[ TFz < < ܅>I ܅>I6 TZz O O Ԛ u E A @&C -YBC 32scc-wkit-clx-227-138.scc.kit.edu Toz 8 8 "A "Aޫ Twz |S E ! ?D\D\ {e{"host_int": 1312442970, "version": [1, 8], "displayname": "", "port": 17500, "namespaces": [193595714, 559360770]} T < < @U9: @U9: ? T < < d26 d26 T O O Ԛ u E A0w @٧ -VeBC 32scc-wkit-clx-227-138.scc.kit.edu T
8 8 Qez Qez T
z.; E @ @צsml 1M-SEARCH * HTTP/1.1
HOST: 239.255.255.250:1900
MAN: "ssdp:discover"
MX: 1
ST: urn:schemas-upnp-org:device:ZonePlayer:1
X-RINCON-HOUSEHOLD: Sonos_rsLnD7TjjlORPKncjdgtbwkQIY
T
8 8 Qez Qez ޫ T$
< < @U9: @U9: { T*
O O Ԛ u E A @> -kBC 32scc-wkit-clx-227-138.scc.kit.edu T6* r r ^ c5 E d q1 PA Axels iPhone _device-info_tcplocal model=N42AP TC* 33 c5` P GN( PH Axels iPhone _device-info_tcplocal model=N42AP TM* V V 33,'@U9:n : BU9: ,' 8 * x:% ,'@U9: Tk* O O Ԛ u E A| @ӿ -o*BC 32scc-wkit-clx-227-138.scc.kit.edu T
O O Ԛ u E A? @Wߍn -e{BC 32scc-wkit-clx-227-138.scc.kit.edu T
< < t/h:! t/h:!% T2 < < S.o"s S.o"s Ю TH O O Ԛ u E A @|& -f BC 32scc-wkit-clx-227-138.scc.kit.edu T < < ߽ T < < سw سw Ӗ T O O Ԛ u E A @U -mBC 32scc-wkit-clx-227-138.scc.kit.edu T/ < < 0 D 0 D[ T< 8 8 "A "Aޫ pktanon-master/tests/pktanon-runtime/istream__socket_output_ip_tcp.exp 0000644 0000000 0000000 00000003164 12701423271 025666 0 ustar root root #
# test for socket-output (test ip4/tcp output)
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/runtimetestlib.exp"]
set_test [info script]
set port 8888
### basic socket (ipv4, tcp) ############################################
log_user 0
# start nmap in ipv4/tcp mode
spawn -noecho ncat -4 -l $port
# start tshark
spawn -noecho sudo tshark -i lo -q -z io,stat,0,ip,ipv6,tcp,udp
expect "Loopback"
# doesn't work without it
sleep 2
set tshark_spawn_id $spawn_id
log_user $log_user_original
# start pktanon
spawn $PKTANON -c $anon_profile -o 127.0.0.1:$port $trace_file
expect {
-re "processed packets:\[ \]*(\[0-9\]+)" { set pkts_sent [expr { $expect_out(1,string) }]; wait; }
eof {fail "$test pktanon failed to initialize"; break;}
timeout {fail "$test pktanon failed to initialize"; break;}
}
log_user 0
set spawn_id $tshark_spawn_id
# doesn't work without it
sleep 2
send \x03
send \x03
expect eof
set buff $expect_out(buffer)
set tshark_stats [count_stats_in_output $buff]
set ip_frames [lindex $tshark_stats 0]
set ip6_frames [lindex $tshark_stats 1]
set tcp_frames [lindex $tshark_stats 2]
set udp_frames [lindex $tshark_stats 3]
vputs "\ncaptured sent frames:"
vputs " stat ip4_frames: expected - some, result - $ip_frames"
vputs " stat ip6_frames: expected - none, result - $ip6_frames"
vputs " stat tcp_frames: expected - some, result - $tcp_frames"
vputs " stat udp_frames: expected - none, result - $udp_frames"
if {$ip_frames <= 0} { fail $test}
if {$ip6_frames > 0} { fail $test}
if {$tcp_frames <= 0} { fail $test}
if {$udp_frames > 0} { fail $test}
log_user $log_user_original pktanon-master/tests/errors/ 0000755 0000000 0000000 00000000000 12701423271 015174 5 ustar root root pktanon-master/tests/errors/eth_ip6.xml 0000644 0000000 0000000 00000001447 12701423271 017262 0 ustar root root
pktanon-master/tests/errors/profile.xml 0000644 0000000 0000000 00000005542 12701423271 017364 0 ustar root root
pktanon-master/tests/errors/bad_udp.pcap 0000644 0000000 0000000 00000001255 12701423271 017442 0 ustar root root ò d ( ( E <Ş@
cu , , E <Ş@
c6gJȡ<] < < E <Ş@
c^ׯy vJy{瓌g 3 3 E <Ş@
cAՠ~,prJ 4K , , E <Ş@
c*O:/ N N E <Ş@
c%s :{FpJ %OA
OL.g l/ 3 3 E <Ş@
c`)
pktanon-master/tests/errors/bad_arp.pcap 0000644 0000000 0000000 00000044154 12701423271 017441 0 ustar root root ò 2%
]%%d#XN%s 0#Ԃ엓 _*k1Y%s %s H%s o "Xu5,Cn2X{ WoϏ(:R %s `̖e5_BzE% (p31%s @w/=%s }Nt0%.8RU'[c%s #%s ךgu't=%G^#K{) )i#c"`{Ƃ%s H3RtϘ_(pYf( fY)OC%s %s OP)=O tYeF9pmopm|J( wa 3XF׀*Aub#
#G?J'_a2kf+%s H)&S MZR@< &דl_ 7]őv%s uUC%s %s 3ѐ*C%s f %s و=Q8ۢ1'iG]B+뢄 2%_\Â,2N-vL.;%s U}W%s %s s+
9N!q uQ!~4T%s Δ%s KZwOLkA2tM/saay7o
粩#<Ũi&nS$#`Ol" Xdso q"Pyj1#@ ;~
-䪦%s %s @Ө0ޖ%s Lx jqN
Kv@{ܝŲx$,lөƨ2!%s HpWr{' z%s 1%s l0Ee2xj
,%׀}9uE2_ PV>vo=Vz w a&գB -^8h%s X{ 1w dڥ b"i %s s 0<0Ag\2%s F%%s `
fF.J%s lhw#+%s )}ak07V%s eL8)5~S 3k>{һ
@%s
!bj&ھj_3Me} G=vxmc%s HvNhxRøfHK9N+#؎_[*0[5YK$T*& :V KMZ%s vA`tLd,MC)T=dXb^"h^D$Ln{pe/xܞ:ڄ]dJ>ʔBsY9D76olz a"`moqt%s - > e ݏ`1;&h;_)?nҔ։ %s /~y82%s ,%s M% Z Ag:銄/"vGw@j]ecB=- UN%s aA^T
G߭cdmxr5LBTK. I ;k$x(~ 1š BQn7 lnA~m̗Z 7+q%s z`ثܘ ]tc og1kK8 Q%s \? a nl%s l QQìw\85
{˕ʤ%s $OK4A[?hh } TR,{%s %s bq
E*Z{%s (],X5n\%s y %s #ɭCoP 'PF::hiv&7 iq 4]i0S|W& 21F%s . 7+
yX %Yd؟%s %s rϠSJpv%_%s Wp8{նv: $
2yJkkSZ8I9 hWIKE%KboŁ'%s Mwm%s =̤J
9# h u4ǜkQ%s oX)7b.%s [t*fl#%s Ƅt>Gi]x1 džr
7JpA%s %s '㤾d0xWبSwe:L%s $zz%s 7
xܼj.NS%s --_R !߱kWRe!kQw"\=1Kx[
&ze=S%s Zf
C5]$ sކz
xR~Xρs'WBHjY[mZ_qv9G>;`=*ИrA 2%%
nU;jzuQ/^t /,%s &asiCDi<$jE`7cc[4MpCJ,r`D Ri[k"A" r` HTdnc i\b[*˄.(V%s Lw rODf$^nٟ%s L#"@^7oy=5؇o+p|;up*;"Z`ֱB1{XO;J͒ 7DF ?&8foh} %s S 0 ,ٰZItR&%s R D, > {
%s (ٞf$%s mBr6C_%s o&$FwjT1qU P_jt9rT2֓#&
o@ju%s 8?yJ*c
%s l>Smq 'v0 ?Rt<L_ ]Jse58$f!DR~%s C&o-%s S>HQcJ`N35a4I< >z^H|^{- p ٞE 8Xt">Z <:ӰeuFQ B^Q?- zQ$cI,]f-d%_Ն
-i5
B(m-H%s .Zc%g6VɈ$#;K%s MɔLAǩ!pJOF`BxVS:
%s P|g2+V ,G\3y,_%s ф$$c!4$t !O& :I h(2R9IH%s ɹA=h
(%s Ý>fDˎԦqjJ%s ȰŢL1
qEqr%s VJփpQpLK)ׇj(zά I!%s cX$մXT"ѭt%s j*2.7^%s %s }6f%s K"аVC|:\k}
%7،'Y7D(/|bp 9~Tr՞],*E8kV]Pr',VY4u~1x: CC(ekM$b\%s qcdy=iLЗ& 71D
pM65vɧ`֜`
1 Ϋz)NN)ˣ5>%s 4{ gL[K(_M6Sm=ݿ\$y5,. 2'74 Iv|GuZTv(dv0nD N+O'z!bMz$%s kqѧG^ + Wv&To%/YVv}om(z"fN ȡom,
|<:|"%s tK%MXSKLb/uCCwCktp2qoBWfx/]P>.Lj=s24Վ:*gqD%s %s =M%s (1tiu%s #8 fC<}:Y1@J+fgA
sB%s (%oLAƒ*Q8feJ F%s 1 ;qt'w}-Sbz$mLe'\|3Gf#ԭF&
C*l6fa+
$Y0ro%s d@X)k Q %s $x?>$U%s egVZ %s J%s {%s dM>{w
3䥱܈}%s tg "K"nc_%xSHTO48;a sSZJcT9L>,%&bf3k):4Zzӡ %s !g
5DqfC3%s Nj%s ^C%s *cٕ͑'ZZA%s uR`hZ%s Q6z %s *%s .b 5Tg{kYn XX%s v>UVtqt9-^3Vr{^+E eivRK<%s TztEuδ>%s RсA@3[%s _zA\
BhTڎefȞ~&ذ3](%s _\Zc PO '㔚PG'jcŌI
!%s HIU,ZŹ
#>ܚښayx^PHA>ӥ`
ulαiĶTnpZ^n%s )d<{%s M 5 *;" 沅>ܫ %`:%s Gau%s %s QөL".,n;%s ˄p6,?y(Gd?RO%s mh3E,ճ:Z oc[3
"aqi1 DGJ1͋%s oa9 d UYb>uP *?@Dot%s QKl$%s h!]>smU)a5 z ӵ[\zPC6.}|R|'-kK"ggL%s aB} %ap/dgd \"CN{Ɩ s'҄
,brGQPy|Ze
I Ks7
B]qTXQLq-p$ܞ%s kJ%s cM4
~5lW
%29Mk:9E݄2%s 1JA5l%s aopf aU4],` L0c_vq1u, P-pT@k/DƁw `l3gPe8zpVz5uQ yu82%s u\f(|,%.%s ǃ%s ?ۣ H>i,%s ||YVJ7GJiW&4 5b>t-:%s %s 4cO~ 2iJj{ց۔
i~Nl{%ml0 zLZmlq߆eHtNn'%s 4 ^])l@m vx +d126]WdUc.&X%s @KJ92f p±$y]O"%s B[e( J=%s D]R%s ZL6ZQ N {}y'^}qb`#AUT.o S-{Y6!tx| K] zВՕ0,1>%s @ ذY6]U@oS.B0- \Al%s UzgJ+t{t8˳ ƪPx %s ֢q%&`x; VwƖQEG%3FJY}C`kQ5h7|
n#_]ȃhQ];[I,w b
Kga=MQ}q>:'>CVZJTUrC" "T"W %s l-VT(1-|2 [U2Q{"SQNBe%s Z܁!D %s hTUCb%s b %s c|VN&Ң0b ~h!
ڰLZ XM%s .DJN %s ,[J ;Eb%s ň\S%s
Clz "ុ}%s %s %s )Icv,o\*C| %s 9EM ( 20[)%l1 .oV}%s %s 6. %s &(.JM@,ю wuڹp 9*8ec NL2F
F'Ww%s h?ֹp%s Z;iWP6-g{ v]pd'MjI1myRV Gܟ P z= 9uLԣMݰ5Ra?l=W1$%s 6%*%s hfN%s %s %s o 9Oа"4*Br$Es77uToY/2%s j ;e%s %s @a6n%s _4!+~'-.Nsm\Q9֘%s ?>UXx32h0 %s %s _ma7f
0/ &_N%s &CB`"Z %s 諍v y̌Nia'}s2)WΒ;%s 4?_3K3t%s u'%s _R6ïׁ^^Fqh.K;0%s ԑp%s 6sÖ|=2 {üb&FLc9Gn4 2%7 2%Zȣ6krͨj0h
v%s n'`ǒ=VV#:%s vC9CAWmQu5 %s ![>%s #J[7֤K"%*q?C
Ṷ̋5KskH;/%s Z6 x! "%3-%s 1ϙQ]~Ўdw[{X\f/3 זwy\~
/$\Kҧl %s l 2,YB>1%s ʆ6Uo%s SX̜%s D,> G? D*&8^}=G_Xu.%s ԇoC%s mjX1Z*(+v%s 7agI?8mX}+s9),mAl4y`5^6%s 7p@ %s Lo FmyL-םS:]FxB ;ETNhT.y5cG^Sid U~a%s ^I>RЈŸ]fO ܺ|r2@tNvۋC Tfw7%s NJ<
|Os}.jCP x[ YvRڟv0,=Eq4zT@깛G9DT #%s 0CZ%s ! +p3"%s @QQjei1Cy %s ns$v ~6M)+
ҐNbV4n6N\.AncN"Bq-\>%s xM09QA%s %%s !M 7m@bE zS3c#%s A 8l
$1Մ+*y@l
_@%s q*(Mb6ͣ.jP #b!dUt'{#N4%s S%s -j͝16ko/~,af
d[N"yGY? prVTv9R K"CGJU6q 3iP_`a
>yem4˩/SRYz҄Oۓ~Xٯ
/r.8z4M ̵%s 68 8oYr"sK;ҟ39q gM>7z%s ݼSdgS@qi;p-,Bh'>Dz-P }Ln7^mĀxy?kT`R9n"-9 nH}Cȱ%s @LܣB3 9pF(@%s KVQy t~(jYyFJɾg. ƞ*i1-mFE^|UL : 2l%s x5JLyk:rt `x]%s T/%s d'}7%֬$ %s ߗMAݶo%'^ xtŁjBV %].O' ɼ&PoU0%Q%s oPF#)T$%s MgӍWDK XΙ+N9~'3ktH
z|4e#d{%E?H1U
t#gOUOI_`{+% o4YT=%s %s Y?&YߋD%s /{%s hUN>[4 fY(@xZ%s
[l`A%s Ÿ{rg8:S ծKQy.Y+{fquf{y'@x/Йc4' Dlv ;~ZI 9h@%r nREg5V"֒H}2҂]F WɊ*:D1W
J1%s wRYŘB \3Ho%s i^X%s +PgVb%s xvr$K[ٙ%s `%s DB%s lvg2Z{+p4I2RgWP3n"SA%s P/)gO(%s .տ Q[
f0yvg9-|ղdyIڳfWkIoM%s 23#*05QɄ@~ѽR8_'X:.>"aC% :Li4@*9K%s ?;%s xu0Zf%s \&qX}|x$k\g?g 'lE: ^T0$(g3ù!I*Ҩ 2%%s Z2 »9=BsYPb)Cx%s pÊnֿ=3֭Ufŝ-$nk.j<6%s dX͘{3>i%S?)%s ])Q趤TakYu%s {,;̋DhH D%s BLGٮq
Iz~FsaE9SudE%s Qe3V5-$z Tpv AYR)z&O/&%s PѴ}Q}%s a%s HÙf[s%s %s ba,yns,/aEejY5_2}mG*fk kN
B Ll_3&ݜ r$vG-D}%s %s ]
%s b ".lċ~ʔ]{Koe+%s %s ;
#p丞+ᶑx-`%s %s ~ox\k%s W9Ne#mJ%s c
%aaP!J2d[uʬУr :7%s 6|6SCFew!%s
$;
4L%%s s3S4%s M,:?#%s !)$)wR3QF7ȰVKI2a\`r,>ia;F'vD*H%s ggһDX+We= N8NIKrp|S%s d
K%s h1d:Bb,ϗ,>DrD|?<%s \ %s %s >%s T3?l&TAǾSJ% |k/XQZN;R`%s VCȱ 8Kk 6pDC!8P7[> %d}u z_:ԪӞGi@%s {Q]%s Bi2by|(֎O] ] j%s mU=<$O9K%s %s ;<"_k_rP{%s *&, %s $! ď
(ɦ[>.o\?X[%s L3#b:@%s c \#Д8v%s W%s - s.,]'a{>+=I%s (/*/=)&Cy_]4x_M%s X plYy%s =.@j%s A](Gεu\;4Y%s }ډ,Ib1i %s |{-RwP%s ͬ)f4%s ݯiVC3`%s _%s CRF`I6a j2 A{1
` aŴ Io"+Iq*VS5;btuf,a%6莋QڌTv
#t %s %s Ď%JVu*v<,a-!ļحZĥt;ub:GEy@ˣ=2mv[x!d٩ ݽH)Gf .n e{$`zoTXTi2PLBT(D1?l`Ylkakcm==gYv:- {
O Zq`ΐƓR(%s tᬬs/ SsDa(Pm10%s 2]0d9љzxꇿ읡s%s P1^lU +U%s >KF7!@ue8YՓ:vz0l$9qiNGn|ȳd|Ax#dU(,Rht [v'lITX(7;B=װ%s Klkj9L_kiiO-o' g+!uTD)BZW0Iu
(%s
u (E"=P?&fK{%s +=}:E pQqW*.wcLCcT_:3zV' Ep{H -MGL25ppp~+d%s bşlC[=.%s t:bv =ӫ"dC Ds2:\%s 蹑O(q}%s
XjPaij U-%s 7^91fmܜe( _%s 8
!2ݹhfxx_̻ \Wen^voxp`нP%s )]H_Gv0 LV|l)%s xOkYϓ*%s e?dk?
t3%G.%s I%s
u0,skyHم?n10 %s {?i%s znz9 %s !%s F
Kx0hC",|Xw':{f|W!f]-uW>%s BX9]Yssb%0%u IZPMv WQ^4nl)Fb%s x6 n*8n%s 3csEr %RqS%s A"o0ɝVBL )nk3n + 75G[
%s &ENWl:ۂ%s PB0%s "*_i %s WxX GoC 7Λ3J"9|ǎ"2;mi*7:=m=od5XejO~\ Vu%s ŚYތu({|%s Պ+L%s q?|/Gvk.L\KQ#O Ğ@0b&Rc@dU Jܨ9)7JsZ0Pa|%khY%s b i3/$ %s *̎9"o K#kJ+5%s @<%K |u%s a`ɖ Eʐ0\TKTnޯϥ/[Wp(. p~ǛIXxzE:%s [4%s E,U SY lW zk%s { <&:Rj Ͻ%s L*F%s `C調9iX%s t.om=[p'Rb|#v4,%s Xަu?ΒaF%s Ø,qf?eh(Н:\vЫ 9։ʮ 'q ;$H΄&Ӷ#lCHJ\%s V?:;(7dsRQ0H_ 0
ޟ ;~f%s _ TKSZHoaWINFeI>H|dW9:s ?eP7
_#;%s z'Ywtx%s Y%s e%s X~cuc\>:+RfKDd) 7TnKSP҂`*WKؙ֧Z7͑82y%%s ..ulF%s ^J66z7xl ً6v8ٝU %rK,kHmEARw`<ad{#W DECjٹ@ϴp O"\lܪƺ=l!3ש 6
&yGR9 . e3%. vSW+7]Yf#rd-Cm+``~lz cҪ p%s ;F9DmQzg5= 4efɂ{'/yMUPD{xa
%s ^%s Kpsi n%s =*,(=ZL&i?%s 8{1y%s ˡޛ7JLl~I-+M+}A>E//wq]'"&_|F 3i|F4l
6
.Q%s H $3v k?I BN<~U]%s 9*& !%s Lqi~%s Mg )%s : E;%s h-%s ՒҲ^ie %s MZEO2IQ%s N윪%"UX$/SZgx*Q<Lv`%s ur8x%s (%s @L+P%s %s 9yk_6볅%s cOThWcϤRBk duԏB]nEZhZ4P >d%s %s !
r+FUd'Wd;sn| [p+(ij;JcNY<rCD%s
%s T|i8%s 0D||m
*A.|k@l%s ?[ q~IN pktanon-master/tests/errors/test_bad_ip.exp 0000644 0000000 0000000 00000001442 12701423271 020170 0 ustar root root #
# test for correct messages by mailformed packets
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/errorstestlib.exp"]
set trace_file [file join $script_dir bad_ip.pcap]
set_test [info script]
spawn $PKTANON -c $anon_profile $trace_file $out_file
expect_error_in_packet 1 "packet is fragmented"
expect_error_in_packet 2 "bogus ip4 header length"
expect_error_in_packet 3 "packet is fragmented"
expect_error_in_packet 4 "packet is fragmented"
expect_error_in_packet 5 "packet is fragmented"
expect_error_in_packet 6 "packet is fragmented"
expect_error_in_packet 7 "packet is fragmented"
expect_error_in_packet 8 "bogus ip4 header length"
expect_error_in_packet 9 "packet is fragmented"
expect_error_in_packet 10 "packet is fragmented"
expect_total_errors 10
wait pktanon-master/tests/errors/eth_ip6_tcp_udp.xml 0000644 0000000 0000000 00000002660 12701423271 020776 0 ustar root root
pktanon-master/tests/errors/test_bad_ethernet.exp 0000644 0000000 0000000 00000000652 12701423271 021400 0 ustar root root #
# test for correct messages by mailformed packets
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/errorstestlib.exp"]
set trace_file [file join $script_dir bad_ethernet.pcap]
set_test [info script]
spawn $PKTANON -c $anon_profile $trace_file $out_file
expect_error_in_packet 2 "ethernet header too short"
expect_error_in_packet 3 "ethernet header too short"
expect_total_errors 2
wait pktanon-master/tests/errors/bad_ethernet.pcap 0000644 0000000 0000000 00000001152 12701423271 020464 0 ustar root root ò d 2~nCaK \`$Ɋ FÀ o%s o 0 `N I I u>WGBnISKҵQ?oBZ%@[ ϳ
1sc ? ? %s y %s 4c\pm%s Tߓi 8cO! <`nvM& I I Eg`%s 8w E}F}%s C-AuTFq<4e} 2 2 sBU Oj*Xe@Ep9 jr0J2^'%s # # P%s (2gvG%2t`kvq ?%s %s 3 3 =Ҽ eX{P< O%s b 6dS|<=(%s _ w 3 3 ps%W\gA0d1!w/ö/ m*#] pktanon-master/tests/errors/test_bad_udp.exp 0000644 0000000 0000000 00000001341 12701423271 020346 0 ustar root root #
# test for correct messages by mailformed packets
#
set script_dir [file dirname [info script]]
source [file join $script_dir "../lib/errorstestlib.exp"]
set trace_file [file join $script_dir bad_udp.pcap]
set_test [info script]
spawn $PKTANON -c $anon_profile $trace_file $out_file
expect_error_in_packet 1 "bad udp length"
expect_error_in_packet 2 "bad udp length"
expect_error_in_packet 3 "bad udp length"
expect_error_in_packet 4 "bad udp length"
expect_error_in_packet 5 "bad udp length"
expect_error_in_packet 6 "bad udp length"
expect_error_in_packet 7 "bad udp length"
expect_error_in_packet 8 "bad udp length"
expect_error_in_packet 9 "bad udp length"
expect_error_in_packet 10 "bad udp length"
expect_total_errors 10
wait pktanon-master/tests/errors/test_ip6_hop_by_hop_opt.exp 0000644 0000000 0000000 00000002231 12701423271 022535 0 ustar root root #
# test that there is no error on traces with IPv6 Hop-by-Hop option
# Hop-by-Hop option has next_header value of 0 and causes problems when
# finding transformations in hash table PHT.h
#
set script_dir [file dirname [info script]]
set trace_file [file join $script_dir trace_hop_by_hop_opt.pcap]
set out_file [file join $script_dir .. out.pcap]
set profile1 [file join $script_dir eth_ip6.xml]
set profile2 [file join $script_dir eth_ip6_icmp6.xml]
set profile3 [file join $script_dir eth_ip6_tcp_udp.xml]
set test [file rootname [ file tail [info script]]]
#### test with eth_ip6 profile
spawn $PKTANON -v -c $profile1 $trace_file $out_file
expect {
"complete" {
expect eof
}
eof {
fail "$test: failed running pktanon with $profile1"
# break
}
}
# spawn $PKTANON -c $profile2 $trace_file $out_file
# expect {
# "complete" {
# expect eof
# }
# eof {
# fail "$test: failed running pktanon with $profile1"
# # break
# }
# }
#
# spawn $PKTANON -c $profile3 $trace_file $out_file
# expect {
# "complete" {
# expect eof
# }
# eof {
# fail "$test: failed running pktanon with $profile1"
# # break
# }
# } pktanon-master/tests/errors/trace_hop_by_hop_opt.pcap 0000644 0000000 0000000 00000052771 12701423271 022243 0 ustar root root ò 5>Tl Z Z 33 xІ` $ 8y!Fb : 5>T > > 33
.ȃ` :
.ȃ 5>Tj` n n 33 g` 8 g :
˔ g5>TTr V V 33~T Z Z 33 &G` $ e4m
: T!
5>T Z Z 33 H$?I` $ N:w/# : < 5>T Z Z 33 Lmm` $ xlF3[ : % ~}5>T Z Z 33 Y` $ Il߅Ù@ : Ù@5>T 33 ^` L ^ : : 5>T V V 33 t/h` : Y ut = u t/h5>T V V 33~T Z Z 33 8D
` $ z/ : V 5>T Z Z 33 rJ` $ )Ώ= : b 5>T Z Z 33 $w& D` $ ; : 5>T] Z Z 33 -` $ {8k : k 5>Tn Z Z 33 O,x,` $ rr) : ] e75>T n n 33 zt}` 8 zt} : W 1$m t}5>T n n 33 d2UN` 8 "d2UN : gڀ UN5>Ta Z Z 33 ` $ |6% : X 5>Tb Z Z 33 S. ݆` $ @|c? : =: EE5>T*4 n n 33 09& B` 8 29& B : d+ 01D B5>T04 Z Z 33 @?S` $ B?S : :5>TV9 Z Z 33 @?S` $ B?S : :5>TZ9 n n 33 !\@'` 8 u : R 5>TͿ 33 @U9:n BU9: : |q
: 5>Tؿ V V 33 @U9:n : BU9: Ƈ * ؍!K @U9:5>T V V 336@U9:n : BU9: 6 _ * _E.6@U9:5>TO n n 33 \QO3f` 8 ^QO3f : ^ 3f5>TO F F 33 /` : / /5>T V V 33~T V V 33 Q@U9:n : BU9: Q #o * " Q@U9:5>T Z Z 33 &^R]6` $ "v : "v5>Tm 33 X5lJ$` L Z5lJ$ : N K = lJ$5>T n 33 1I` L w[I : 5 W 5>TDr n n 33 +4` 8 KbݻA : GI ƌ 5>TIr 33 1 iM` t HP!~ : c G 4k uI !~5>TLr Z Z 33 vig` $ U7Mz : 5>Tu n n 33 S. ݆` 8 @|c? : ѥ ? 5>Tu V V 33 t/h` : Y ut = u t/h5>Tu 33 < z"` t hY Q : ̐q ~ Q5>T Z Z 33 Vi` $ VY : 5>T 33 x9І` L z9 : % P 5>T Z Z 33 ĕF` $ F : 9 F5>T Z Z 33 H$?I` $ N:w/# : D 5>T Z Z 33 Y` $ Il߅Ù@ : S 5>TO v v 33 @U9:n @: BU9: Mb@H, )2 @U9: @ ' : * 5>TO Z Z 33 &kA` $ &kA : &kA5>TPm Z Z 33 t` $ t : f
t5>TWm Z Z 33 <` $ < : ] 5>TYm Z Z 33 &^R]6` $ "v : 0 5>T Z Z 33 $>` $ D^\ : \5>T Z Z 33 N6C` $ <>L 6& : 5>T
Z Z 33 rJ` $ )Ώ= : ͟ =5>TK V V 33 @U9:n : BU9: Ƈ * ؍!K @U9:5>TR V V 336@U9:n : BU9: 6 _ * _E.6@U9:5>TY V V 33 t/h` : Y ut = u t/h5>T\ Z Z 33 O,x,` $ rr) : 1 )5>T( Z Z 33 &` $ eR0D : 5>T- F F 33 <ʬ` : Y8 6 <ʬ5>TgD
33 85Rhd` L 85Rhd : Kw Rhd5>T > > 33 OՑ'(` : ȃgcd _ 5>T Z Z 33 Vi` $ VY : ۻ 0 5>T" n n 33 `!Ɔ` 8 b! : ^\ 5>TU= Z Z 33 ̯xsyφ` $ 2~a, : ' 5>TCb > > 33 \[` c( : [Ugq 5>T > > 33 T Z Z 33 Y` $ Il߅Ù@ : S 5>T {
Z Z 33 $w& D` $ ; : F 5>T~
n n 33 }q` 8 }q : }q5>T~
V V 33'6@U9:n : BU9: '6 * '6@U9:5>T} n n 33 v` 8 Y
Fo : T4
Fo װ5>T V V 33 @U9:n : BU9: Ƈ * ؍!K @U9:5>T F F 33 <ʬ` : Y8 6 <ʬ5>T V V 33 t/h` : Y ut = u t/h5>T
Z Z 33 H$Mچ` $ G[ V : } Q 5>T$
n n 33 -#` 8 -# : t {( #5>T6
Z Z 33 $>` $ D^\ : 5] ,5>Te Z Z 33 ^U%` $ ^U% : P U%5>T$+ Z Z 33 vig` $ U7Mz : 0 ki5>T7+ 33 h` L h : J n h5>TF+ Z Z 33 S. ݆` $ @|c? : 5>TN+ F F 33 OՑ'(` : ȃgcd OՑ'(5>TX+ V V 33&@U9:n : BU9: & p * s&@U9:5>T 2 Z Z 33 N6C` $ <>L 6& : b u%5>T.2 33 P` t Ĉ̾ : H yA ! \R 5>TH2 n n 33 \[` 8 [Ugq : vV5>Tx Z Z 33 *p` $ m1 : 5>T1x V V 33]@U9:n : BU9: ] 1 *
?O]@U9:5>Ti{ Z Z 33 8D
` $ z/ : s /5>T" Z Z 33 $w& D` $ ; : > 5>T> F F 33 ^{r` : ^{r - ^{r5>Tf Z Z 33 8 @2:.` $ : 5* 2:.5>T5 F F 33 :l` : :l v :l5>Ta Z Z 33 H$Mچ` $ G[ V : [c 5>T+ V V 33 H$Y` J$Y : 5>T+ Z Z 33 $>` $ D^\ : a! 5>T%+ V V 336@U9:n : BU9: 6 _ * _E.6@U9:5>T.+ Z Z 33 䔘` $ %c : < ` 5>Tѿ F F 33 S.o` : ;:I Nv S.o5>Ty n n 33 ą` 8 ƅ : W | 1 5>T F F 33 T}I Z Z 33 Y` $ Il߅Ù@ : R 5>T,j Z Z 33 &` $ eR0D : ' E}5>T5j F F 33 <ʬ` : Y8 6 <ʬ5>T-
n n 33 =1` 8 =1 : LY 15>Ty 33 &ި` ` &ި : i u0 ި5>T 33 ` t Q͑t. : T " : 0 .5>T 33 ؖ%^` t A> : z ԧ >5>TB F F 33 OՑ'(` : ȃgcd OՑ'(5>TC 33 V/4.` L V/4. : 0 /4.5>TI 33 \[` U
n [Ugq nlq
Mohameds iPad _device-info_tcplocal model=J72AP ) |\[\[5>T n n 33 0f4` 8 2f4 : R ! f45>T Z Z 33 *p` $ m1 : 5>Tb V V 33]@U9:n : BU9: ] 1 *
?O]@U9:5>Tf n n 33 \$)o` 8 ^$)o : h J )o5>Tm v v 33 @U9:n @: BU9: Mb@H, )2 @U9: @ ' : * 5>Top Z Z 33 ̯xsyφ` $ 2~a, : a,5>T 33 pVbӆ` rVb : ) փ v ^ 6 q/ b5>T Z Z 33 H$Mچ` $ G[ V : V 5>T n n 33 Fe҆` 8 Fe : \ Kr 5>T Z Z 33 uV` $ xv7. : 5>T Z Z 33 rJ` $ )Ώ= : bw 5>T V V 33:̯x` : Jڝ 9R : BU9:̯x5>Tf< n n 33 "` 8 " : u "5>T@ V V 33'f@U9:n : BU9: 'f * Ȧ'f@U9:5>TD Z Z 33 ̯xsyφ` $ 2~a, : 5>TD F F 33 ^{r` : ^{r - ^{r5>TJV Z Z 33 ` $ |6% : %5>T^ Z Z 33 vig` $ U7Mz : 5>T_ b b 33 \[` , [Ugq "# , U \[ 5>T_ F F 33 hêچ` : h aR hê5>T_ Z Z 33 U!2` $ ~< : ~<5>T_ n n 33 x:!` 8 0* : t _ rj5>T9 33 X D` t 'O : f ( O
5>TA 33 \[` ` [Ugq : y ) vV B`7 gq5>TC 33 \[` L [Ugq : P ) vV gq5>TF > > 33 \=` : |
X 5>TK 33 \[` U
n [Ugq nlq
Mohameds iPad _device-info_tcplocal model=J72AP ) |\[\[5>T Z Z 33 &G` $ e4m
: 5>T Z Z 33 Lmm` $ xlF3[ : [5>T'A V V 33YH$Y` J$Y Y: Y5>T N N 33vV\[` : vV N * 'vV5>T V V 33]@U9:n : BU9: ] 1 *
?O]@U9:5>T Z Z 33 &` $ eR0D : 5>TV N N 33)\[` : ) * Y`vip)5>T* F F 33 &q҆` : Ӻ>
&q5>T Z Z 33 -` $ {8k : k5>T Z Z 33 v` $ Y
Fo : KY 5>T V V 33'f@U9:n : BU9: 'f * Ȧ'f@U9:5>T#
33 !jqJ` L !jqJ : i N qJ5>T $
> > 33 \qĆ` : ;- 5>Tb*
n n 33 Ώ$Qކ` 8 Ώ$Q : k* > 5>Tl*
n n 33 5t` 8 .) : 5>Tp*
33 #S ` L #S : Q (9 p S 5>Ts*
33 @j` L @j : ϖ j vՇ j5>T8 33 hmQ` ` jmQ : R . Q5>T@ Z Z 33 ` $ |6% : ` 5>TB Z Z 33 䔘` $ %c : & 5>T Z Z 33 Vi` $ VY : ` 5>T n n 33 $8` 8 $8 : V $85>T
Z Z 33 &G` $ e4m
: @ 5>T
Z Z 33 ¶g` $
g : g5>TY Z Z 33 rJ` $ )Ώ= : a 5>T 33 ⇾A` L A : 4K A A5>T{' Z Z 33 v` $ Y
Fo : Ka 5>T' Z Z 33 &` $ eR0D : 5>T?- V V 33]@U9:n : BU9: ] 1 *
?O]@U9:5>TV 33 !jq̆` L !jq : \ q5>Ty V V 33H$` J$ : ߆ 5>T Z Z 33 &^R]6` $ "v : 2ik5>T F F 33 8` : 8 85>TŹ V V 33:t/h` : Y ut : ݟ BU9:t/h5>T۹ V V 33:t/h` :* 4pJf. : 6 BU9:t/h5>T E x x 33 t/h` B Y ut "# Br z Ct/h 7 MSFT 5.0 5>T>E V V 33` @U9:n : BU9: ` * HZ` @U9:5>TJE Z Z 33 t/h` $ Y ut : 'B 5>TdE n n 33 :a8` 8 :a8 : N . 85>TqE V V 33It+}|` 9D\Ц I: P I5>TE Z Z 33 t/h` $ Y ut : &B 5>TE Z Z 33 t/h` $ Y ut : 'B 5>TE V V 33:t/h` : Y ut : ݟ BU9:t/h5>T%M Z Z 33 U!2` $ ~< : t 5>T7M Z Z 33 t/h` $ Y ut : &B 5>TEM W W 33 t/h` ! Y ut 6 ! MedBook 5>TVM Z Z 33 N6C` $ <>L 6& : 5>T`M F F 33 R}DĆ` : R}D x R}D5>TwM N N 33tt/h` : t a Y ut5>TM N N 33tt/h` : t @ * Y ut5>TM N N 33Jf.t/h` : Jf. Ҁ * 4pJf.5>TM F F 33 t/h` : Y ut t/h5>TM 33 t/h` ` Y ut : Cq t Jf. 5>TM Z Z 33 Vi` $ VY : h pktanon-master/tests/errors/bad_ip.pcap 0000644 0000000 0000000 00000001331 12701423271 017255 0 ustar root root ò d 8 8 {tn[a1&}B1{%s }6ڦ z $ $ ~#& %| ʤ- A A {{I/ Ɔ@%=%s %+AS%s Kw
rJT7sFQ 6 6 W.N`r%s Riloπ[
A\N f , 1 1 |_u@%s (qYQpu[K} K K mhkgPꉳ1]Q /J. ` 0 0 ~ R}!:~B N'YvS " " łO\)nz 0 0 BǚNт<^Wa++Z P P ,
HR[9 fէO#D M )b%s ^sCt泊5xZU pktanon-master/tests/errors/bad_tcp.pcap 0000644 0000000 0000000 00000001541 12701423271 017436 0 ustar root root ò d 5 5 @h i hg E ( @ 7'"<3VsWŊz V V @h i hg E ( @ 7'"<:N]/8c.v =|44$@9z68p S S @h i hg E ( @ 7'"<4}d9;cy6mf(:cd9 crz_kP S S @h i hg E ( @ 7'"E3 S S @h i hg E ( @ 7'"IK? 7 7 @h i hg E ( @ 7'" 0 } {
puts $msg
}
}
proc set_test { script_name } {
global verbose
global test
set test [file rootname [ file tail $script_name]]
if { [info exists test] && $verbose > 0 } {
puts "================== $test =================="
}
}
proc match_io_logs {io_log_prefix} {
global test
global expect_out
if {![regexp -line -lineanchor "^$io_log_prefix:" $expect_out(buffer)]} { fail "$test pktanon is not using correct io"}
}
# count number of frames in pcap file
#
# tshark output is something like this
# ===================================
# | IO Statistics |
# | |
# | Duration: 0.044 secs |
# | Interval: 0.044 secs |
# | |
# | Col 1: FRAMES |
# |---------------------------------|
# | |1 | |
# | Interval | FRAMES | |
# |-------------------------| |
# | 0.000 <> 0.044 | 9976 | |
# ===================================
proc count_frames_in_output { buff } {
set frames_cntr unknown
regexp -line -lineanchor {^\|\s0\.00?0?[ <>0-9.]+\s\|\s*(\d+)} $buff match frames_cntr
regexp -line -lineanchor {^\|\s0\.000[ <>0-9.]+\|\s*(\d+)} $buff match frames_cntr
return $frames_cntr
}
proc count_frames { pcap_file {filter FRAMES} } {
set log_user_original [log_user -info]
log_user 0
spawn -noecho tshark -r $pcap_file -q -z io,stat,0,$filter
expect {
eof {set buff $expect_out(buffer)}
}
log_user $log_user_original
return [count_frames_in_output $buff]
}
proc count_stats_in_output { buff } {
set found [regexp -line -lineanchor {^\|\s*0\.0+[ <>0-9.]+\|\s*(\d+)\s\|\s*\d+\s\|\s*(\d+)\s\|\s+\d+\s\|\s+(\d+)\s\|\s+\d+\s\|\s+(\d+)} $buff match ip_frames ip6_frames tcp_frames udp_frames ]
if { $found != 1} { return {} }
set rlist [list $ip_frames $ip6_frames $tcp_frames $udp_frames]
return $rlist
}
proc count_stats { pcap_file } {
# TODO log_user 0
spawn -noecho tshark -r $pcap_file -q -z io,stat,0,ip,ipv6,tcp,udp
expect {
eof {set buff $expect_out(buffer)}
}
count_stats_in_output $buff
}
proc compare_stats { expected_pcap_file result_pcap_file } {
global test
set log_user_original [log_user -info]
log_user 0
if { ![file exists $expected_pcap_file] } {
fail "$test - file $expected_pcap_file does not exist"
}
if { ![file exists $expected_pcap_file] } {
fail "$test - file $result_pcap_file does not exist"
}
set stats_exp_pcap [count_stats $expected_pcap_file]
set stats_out_pcap [count_stats $result_pcap_file]
set stats_names {"ip4" "ip6" "tcp" "udp"}
vputs "\nframes counter:"
for {set i 0} {$i < [llength $stats_exp_pcap]} {incr i} {
set stat_expected [lindex $stats_exp_pcap $i]
set stat_result [lindex $stats_out_pcap $i]
vputs " stat [lindex $stats_names $i]: expected - $stat_expected, result - $stat_result"
if { $stat_expected != $stat_result} { fail "$test, wrong stat $i; expected: $stat_expected, result: $stat_result"}
}
log_user $log_user_original
}
proc test_sudo_nopwd { } {
try {
set results [exec sudo -nv ]
set status 0
} trap CHILDSTATUS {results options} {
set status [lindex [dict get $options -errorcode] 2]
}
return $status
} pktanon-master/tests/lib/errorstestlib.exp 0000644 0000000 0000000 00000001621 12701423271 020047 0 ustar root root ### initialize variables
set anon_profile [file join $script_dir profile.xml]
set out_file [file join $script_dir .. out.pcap]
set log_user_original [log_user -info]
proc set_test { script_name } {
global verbose
global test
set test [file rootname [ file tail $script_name]]
if { [info exists test] && $verbose > 0 } {
puts "================== $test =================="
}
}
proc expect_error_in_packet { pkt_num error_text} {
global test;
if { [catch {
expect {
"warning: error in packet $pkt_num: $error_text" {}
eof {fail "$test on pkt_num = $pkt_num";}
}
} ] } {fail "$test on pkt_num = $pkt_num";}
}
proc expect_total_errors { total_errors } {
global test;
if { [catch {
expect {
-re "errors in packets:.$total_errors" {}
eof {fail "$test on total errors = $total_errors";}
}
} ] } {fail "$test on total errors = $total_errors";}
} pktanon-master/tests/lib/anonprimitives.exp 0000644 0000000 0000000 00000000414 12701423271 020212 0 ustar root root puts ""
puts "============================================================================"
puts "=================== test suite for anon primitives ========================="
puts "============================================================================"
puts ""
pktanon-master/tests/lib/transformations.exp 0000644 0000000 0000000 00000000414 12701423271 020374 0 ustar root root puts ""
puts "============================================================================"
puts "=================== test suite for transformations ========================="
puts "============================================================================"
puts ""
pktanon-master/tests/lib/transftestlib.exp 0000644 0000000 0000000 00000004424 12701423271 020034 0 ustar root root proc vputs { msg } {
global verbose
if { $verbose > 0 } {
puts $msg
}
}
proc exec_pktanon { anon_profile in_file } {
global test
global PKTANON
set base_dir [file dirname [info script]]
set anon_profile [file join $base_dir $anon_profile]
set in_file [file join $base_dir $in_file]
set out_file [file join $base_dir ../out.pcap]
spawn $PKTANON -c $anon_profile $in_file $out_file
expect {
"complete" { expect eof; vputs "\n"; return 1}
eof {
fail "$test: pktanon failed to run"
return 0
}
}
}
proc test_field {field value} {
global test
global verbose
set log_user_original [log_user -info]
log_user 0
set base_dir [file dirname [info script]]
set out_file [file join $base_dir ../out.pcap]
if { [string first 0x $value ] == 0 } {
set value [expr $value]
}
spawn -noecho tshark -T fields -e $field -o tcp.analyze_sequence_numbers:False -r $out_file
expect {
$value {
wait
vputs "PASS: $test $field = $value"
pass "$test $field"
}
eof {
fail "$test: test for field $field failed: \n expected: $value\n actual: $expect_out(buffer)"
}
}
log_user $log_user_original
}
proc test_checksum {proto} {
global test
global verbose
set log_user_original [log_user -info]
log_user 0
set base_dir [file dirname [info script]]
set out_file [file join $base_dir ../out.pcap]
spawn -noecho tshark -T fields -e $proto.checksum_good -o tcp.check_checksum:True -r $out_file
expect {
"1" {
vputs "PASS: $test $proto.checksum_good"
pass "$test $proto.checksum_good\n"
}
"0" {
fail "$test: test for $proto.checksum failed: checksum is bad\n"
}
}
log_user $log_user_original
}
proc test_checksum_r {proto} {
global test
global verbose
set log_user_original [log_user -info]
log_user 0
set base_dir [file dirname [info script]]
set out_file [file join $base_dir ../out.pcap]
spawn tshark -T fields -e $proto.checksum_bad -o tcp.check_checksum:True -r $out_file
expect {
"0" {
vputs "PASS: $test !$proto.checksum_bad"
pass "$test $proto.checksum_good\n"
}
"1" {
fail "$test: test for !$proto.checksum_bad failed: checksum is bad\n"
}
}
log_user $log_user_original
} pktanon-master/tests/lib/anontestlib.exp 0000644 0000000 0000000 00000002354 12701423271 017472 0 ustar root root proc anon_value_test { anon_class params src exp_dst } {
global test
global ANONTESTER
spawn $ANONTESTER
foreach param_name [dict keys $params] {
set param_value [dict get $params $param_name]
expect "enter command:"
send "p $param_name $param_value\n"
}
expect "enter command:"
send "a $anon_class\n"
expect "enter command:"
send "v $src\n"
expect -re "result = {(.*)}" { set value [expr { $expect_out(1,string) }];}
expect "enter command:"
send "q"
if { $value == $exp_dst } { pass $test } {
fail "$test\texp: {$exp_dst}\n\t\tres: {$value}" }
}
proc anon_chain_test { params anons buffer expected_result } {
global test
global ANONTESTER
spawn $ANONTESTER
foreach param_name [dict keys $params] {
set param_value [dict get $params $param_name]
expect "enter command:"
send "p $param_name $param_value\n"
}
foreach anon_class $anons {
expect "enter command:"
send "a $anon_class\n"
}
expect "enter command:"
send "v $buffer\n"
expect -re "result = {(.*)}" { set value [expr { $expect_out(1,string) }];}
expect "enter command:"
send "q"
if { $value == $expected_result } { pass $test } {
fail "$test\texp: {$expected_result}\n\t\tres: {$value}" }
} pktanon-master/tests/lib/pktanon-runtime.exp 0000644 0000000 0000000 00000000414 12701423271 020276 0 ustar root root puts ""
puts "============================================================================"
puts "=================== test suite for pktanon console app ====================="
puts "============================================================================"
puts ""
pktanon-master/tests/config/ 0000755 0000000 0000000 00000000000 12701423271 015125 5 ustar root root pktanon-master/tests/config/unix.exp 0000644 0000000 0000000 00000002037 12701423271 016630 0 ustar root root if {![info exists TOP_SRC_DIR]} {
set pwd [pwd];
set pwd [file split $pwd];
set pktanon_dir list
foreach path_element $pwd {
lappend pktanon_dir $path_element
if { $path_element == "pktanon"} { break;}
}
set pktanon_dir [file join {*}$pktanon_dir]
} else {
set pktanon_dir [file join [pwd] $TOP_SRC_DIR]
}
set pktanon_exec [file join $pktanon_dir pktanon]
set top_tests_dir [file join $pktanon_dir tests]
set anontester_exec [file join $top_tests_dir anontester]
if { [file exists $pktanon_exec] } { set PKTANON $pktanon_exec} {
error "path to pktanon not found, if TOP_SRC_DIR is not pktanon, set TOP_SRC_DIR variable"
}
if { [file exists $anontester_exec] } { set ANONTESTER $anontester_exec} {
error "path to pktanon not found, if TOP_SRC_DIR is not pktanon, set TOP_SRC_DIR variable"
}
set TESTS_DIR $top_tests_dir
if {$verbose > 0} { log_user 1 }
unset pktanon_dir
unset pktanon_exec
unset anontester_exec
unset top_tests_dir
proc vputs { msg } {
global verbose
if { $verbose > 0 } {
puts $msg
}
} pktanon-master/libpktanon/ 0000755 0000000 0000000 00000000000 12701423271 014657 5 ustar root root pktanon-master/libpktanon/transformations/ 0000755 0000000 0000000 00000000000 12701423271 020110 5 ustar root root pktanon-master/libpktanon/transformations/LinuxCookedCaptureTransformation.h 0000644 0000000 0000000 00000002452 12701423271 026763 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_LINUXCOOKEDCAPTURETRANSFORMATION_H
#define PKTANON_LINUXCOOKEDCAPTURETRANSFORMATION_H
# include "Transformation.h"
namespace pktanon
{
# pragma pack (1)
struct LINUX_SLL_HEADER
{
uint16_t packet_type;
uint16_t hardware_type;
uint16_t link_layer_addr_len;
uint8_t link_layer_addr[8];
uint16_t protocol_type;
};
# pragma pack ()
class LinuxCookedCaptureTransformation : public Transformation
{
public:
LinuxCookedCaptureTransformation(
AnonPrimitive* anon_packet_type,
AnonPrimitive* anon_hardware_type,
AnonPrimitive* anon_link_layer_addr,
AnonPrimitive* anon_protocol_type
);
virtual int transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
private:
const AnonPrimitive* const anon_packet_type;
const AnonPrimitive* const anon_hardware_type;
const AnonPrimitive* const anon_link_layer_addr;
const AnonPrimitive* const anon_protocol_type;
};
}
#endif // PKTANON_LINUXCOOKEDCAPTURETRANSFORMATION_H
pktanon-master/libpktanon/transformations/EthernetPacketTransformation.h 0000644 0000000 0000000 00000002376 12701423271 026126 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ETHERNETPACKETTRANSFORMATION_H
#define PKTANON__ETHERNETPACKETTRANSFORMATION_H
#include "Transformation.h"
#include "transformations/Addresses.h"
namespace pktanon
{
# pragma pack (1)
struct ETHERNET_HEADER
{
ETHERNET_HEADER() : type (0) {};
MAC_ADDR destination;
MAC_ADDR source;
uint16_t type;
};
# pragma pack ()
class EthernetPacketTransformation : public Transformation
{
public:
enum class PAD
{
ALWAYS,
KEEP_LEN,
NEVER,
};
~EthernetPacketTransformation();
EthernetPacketTransformation (AnonPrimitive* anon_dest_mac, AnonPrimitive* anon_source_mac, AnonPrimitive* anon_ethertype, PAD pad_mode);
virtual int transform (const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
private:
const AnonPrimitive* const anon_dest_mac;
const AnonPrimitive* const anon_source_mac;
const AnonPrimitive* const anon_ethertype;
const PAD pad_mode;
};
}
#endif // PKTANON_ETHERNETPACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/UdpPacketTransformation.h 0000644 0000000 0000000 00000002344 12701423271 025073 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_UDPPACKETTRANSFORMATION_H
#define PKTANON_UDPPACKETTRANSFORMATION_H
# include "transformations/PseudoheaderAwareTransformation.h"
namespace pktanon
{
# pragma pack (1)
struct UDP_HEADER
{
uint16_t source_port;
uint16_t destination_port;
uint16_t length;
uint16_t checksum;
};
# pragma pack ()
class UdpPacketTransformation : public PseudoheaderAwareTransformation
{
public:
virtual ~UdpPacketTransformation();
UdpPacketTransformation(AnonPrimitive* anon_source_port, AnonPrimitive* anon_destination_port);
virtual int transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
virtual int calculate_checksum(uint8_t* source_address, uint8_t* destination_address, unsigned address_length, uint16_t ip_length, uint8_t* sink_next_header) const noexcept;
private:
AnonPrimitive* anon_source_port;
AnonPrimitive* anon_destination_port;
};
}
#endif // PKTANON_UDPPACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/UdpLitePacketTransformation.h 0000644 0000000 0000000 00000002141 12701423271 025704 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_UDPLITEPACKETTRANSFORMATION_H
#define PKTANON_UDPLITEPACKETTRANSFORMATION_H
# include
namespace pktanon
{
# pragma pack (1)
struct UDPLITE_HEADER
{
uint16_t source_port;
uint16_t destination_port;
uint16_t checksum_coverage;
uint16_t checksum;
};
# pragma pack ()
class UdpLitePacketTransformation : public Transformation
{
public:
virtual ~UdpLitePacketTransformation();
UdpLitePacketTransformation(
AnonPrimitive* anon_source_port,
AnonPrimitive* anon_destination_port,
AnonPrimitive* anon_checksum_coverage
);
size_t transform(uint8_t* source_buffer, uint8_t* destination_buffer) const;
private:
AnonPrimitive* anon_source_port;
AnonPrimitive* anon_destination_port;
AnonPrimitive* anon_checksum_coverage;
};
}
#endif // PKTANON_UDPLITEPACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/IPv4PacketTransformation.h 0000644 0000000 0000000 00000006142 12701423271 025125 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_IPV4TRANSFORMATION_H
#define PKTANON_IPV4TRANSFORMATION_H
# include "Transformation.h"
namespace pktanon
{
# pragma pack (1)
struct IPv4_HEADER
{
uint8_t version__header_len;
uint8_t tos;
uint16_t total_length;
uint16_t identification;
uint16_t flags__fragment_offset;
uint8_t ttl;
uint8_t protocol;
uint16_t header_checksum;
in_addr source_ip;
in_addr destination_ip;
};
# pragma pack ()
class IPv4PacketTransformation : public Transformation
{
public:
~IPv4PacketTransformation();
/**
* If you have a procedure with 10 parameters, you probably missed some.
*/
IPv4PacketTransformation (
AnonPrimitive* anon_tos,
AnonPrimitive* anon_identification,
AnonPrimitive* anon_flags,
AnonPrimitive* anon_fragment_offset,
AnonPrimitive* anon_ttl,
AnonPrimitive* anon_protocol,
AnonPrimitive* anon_source_ip,
AnonPrimitive* anon_destination_ip,
AnonPrimitive* anon_options,
bool recalculate_ipv4_header_checksum,
bool recalculate_payload_checksums
);
virtual int transform (const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
static uint8_t get_version (IPv4_HEADER* header)
{
return ( (header->version__header_len & 0xF0) >> 4);
}
static void set_version (uint8_t version, IPv4_HEADER* header)
{
header->version__header_len = ( (version & 0xF) << 4) | (get_header_len (header) / 4);
}
static uint8_t get_header_len (IPv4_HEADER* header)
{
return ( (header->version__header_len & 0x0F) << 2);
}
static void set_header_len (uint16_t len, IPv4_HEADER* header)
{
header->version__header_len = (get_version (header) << 4) | ( ( (len / 4) & 0xF));
}
static uint16_t get_flags (IPv4_HEADER* header)
{
return ( (header->flags__fragment_offset & 0xE000) >> 13);
}
static void set_flags (uint16_t flags, IPv4_HEADER* header)
{
header->flags__fragment_offset = ( (uint16_t) (flags & 0x07) << 13) | get_fragment_offset (header);
}
static uint16_t get_fragment_offset (IPv4_HEADER* header)
{
return ( (header->flags__fragment_offset & 0x1FFF)) ;
}
static void set_fragment_offset (uint16_t fragment_offset, IPv4_HEADER* header)
{
header->flags__fragment_offset = ( (get_flags (header) & 0x07) << 13) | (0xD & fragment_offset);
}
private:
const AnonPrimitive* const anon_tos;
const AnonPrimitive* const anon_identification;
const AnonPrimitive* const anon_flags;
const AnonPrimitive* const anon_fragment_offset;
const AnonPrimitive* const anon_ttl;
const AnonPrimitive* const anon_protocol;
const AnonPrimitive* const anon_source_ip;
const AnonPrimitive* const anon_destination_ip;
const AnonPrimitive* const anon_options;
const bool recalculate_ipv4_header_checksum;
const bool recalculate_payload_checksums;
};
}
#endif // PKTANON_IPV4TRANSFORMATION_H
pktanon-master/libpktanon/transformations/PayloadTransformation.cpp 0000644 0000000 0000000 00000001652 12701423271 025140 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "PayloadTransformation.h"
using namespace pktanon;
PayloadTransformation::~PayloadTransformation()
{
delete payload_anon;
}
PayloadTransformation::PayloadTransformation ( AnonPrimitive* payload_anon ) :
payload_anon ( payload_anon )
{}
namespace pktanon
{
int PayloadTransformation::transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length ) const noexcept
{
// size_t new_length = transform_field (payload_anon, source_buffer, destination_buffer, max_packet_length);
size_t new_length = payload_anon->anonimyze ( source_buffer, destination_buffer, max_packet_length );
return new_length;
}
}
pktanon-master/libpktanon/transformations/UdpLitePacketConfigurator.cpp 0000644 0000000 0000000 00000000515 12701423271 025676 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "UdpLitePacketConfigurator.h"
using namespace pktanon;
pktanon-master/libpktanon/transformations/PseudoheaderAwareTransformation.h 0000644 0000000 0000000 00000002016 12701423271 026577 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_PSEUDOHEADER_AWARETRANSFORMATION_H
# define PKTANON_PSEUDOHEADER_AWARETRANSFORMATION_H
# include "Transformation.h"
namespace pktanon
{
class PseudoheaderAwareTransformation : public Transformation
{
public:
virtual ~PseudoheaderAwareTransformation();
public:
// virtual size_t verify_checksum(uint8_t protocol, uint16_t length, uint8_t* source_address, uint8_t* destination_address, size_t address_length, uint8_t* source_next_header);
virtual int calculate_checksum(uint8_t* source_address, uint8_t* destination_address, unsigned address_length, uint16_t ip_length, uint8_t* sink_next_header) const noexcept = 0;
};
inline PseudoheaderAwareTransformation::~PseudoheaderAwareTransformation()
{}
}
#endif // PKTANON_TRANSFORMATION_H
pktanon-master/libpktanon/transformations/Addresses.h 0000644 0000000 0000000 00000000712 12701423271 022176 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_ADDRESSES_H
#define PKTANON_ADDRESSES_H
namespace pktanon
{
static const unsigned int ETHER_ADDR_LEN = 6;
struct MAC_ADDR
{
uint8_t addr[ETHER_ADDR_LEN];
};
}
#endif
pktanon-master/libpktanon/transformations/IPv4PacketTransformation.cpp 0000644 0000000 0000000 00000016252 12701423271 025463 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "IPv4PacketTransformation.h"
#include "PseudoheaderAwareTransformation.h"
#include "ErrorCodes.h"
//------------------------------------------------------------
#include "debug.h"
#include
using namespace pktanon;
IPv4PacketTransformation::~IPv4PacketTransformation()
{
delete anon_tos;
delete anon_identification;
delete anon_flags;
delete anon_fragment_offset;
delete anon_ttl;
delete anon_protocol;
delete anon_source_ip;
delete anon_destination_ip;
delete anon_options;
}
IPv4PacketTransformation::IPv4PacketTransformation (
AnonPrimitive* anon_tos,
AnonPrimitive* anon_identification,
AnonPrimitive* anon_flags,
AnonPrimitive* anon_fragment_offset,
AnonPrimitive* anon_ttl,
AnonPrimitive* anon_protocol,
AnonPrimitive* anon_source_ip,
AnonPrimitive* anon_destination_ip,
AnonPrimitive* anon_options,
bool recalculate_ipv4_header_checksum,
bool recalculate_payload_checksums
) :
anon_tos (anon_tos),
anon_identification (anon_identification),
anon_flags (anon_flags),
anon_fragment_offset (anon_fragment_offset),
anon_ttl (anon_ttl),
anon_protocol (anon_protocol),
anon_source_ip (anon_source_ip),
anon_destination_ip (anon_destination_ip),
anon_options (anon_options),
recalculate_ipv4_header_checksum(recalculate_ipv4_header_checksum),
recalculate_payload_checksums(recalculate_payload_checksums)
{ }
/// convert fields to host byte order
static inline void prepare_input_header (IPv4_HEADER* input_header)
{
Transformation::ntoh16 (input_header->total_length);
Transformation::ntoh16 (input_header->identification);
Transformation::ntoh16 (input_header->flags__fragment_offset);
Transformation::ntoh16 (input_header->header_checksum);
}
/// convert fields back to network byte order and recalculate header_checksum
static inline void prepare_output_header (IPv4_HEADER* output_header, bool recalculate_checksum = true)
{
Transformation::hton16 (output_header->total_length);
Transformation::hton16 (output_header->identification);
Transformation::hton16 (output_header->flags__fragment_offset);
// TODO set to random value on error?
output_header->header_checksum = 0;
if (recalculate_checksum)
{
// recalculate header checksum
Checksum checksum;
checksum.update (output_header, sizeof (IPv4_HEADER));
output_header->header_checksum = checksum.final();
Transformation::hton16(output_header->header_checksum);
// TRACE(std::hex << output_header->header_checksum);
}
Transformation::hton16 (output_header->header_checksum);
}
int IPv4PacketTransformation::transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
size_t ip_header_length = sizeof (IPv4_HEADER);
if (max_packet_length < ip_header_length)
{
return error_codes::ip4_header_too_short;
}
IPv4_HEADER* input_header = (IPv4_HEADER*) source_buffer;
IPv4_HEADER* output_header = (IPv4_HEADER*) destination_buffer;
prepare_input_header (input_header);
// save required fields
size_t original_header_length = get_header_len (input_header);
uint8_t transport_protocol = input_header->protocol;
// transform packet
set_version (4, output_header);
transform_field (anon_tos, &input_header->tos, &output_header->tos, sizeof (uint8_t));
transform_field (anon_identification, &input_header->identification, &output_header->identification, sizeof (uint16_t));
uint16_t flags = get_flags (input_header);
uint16_t flags_output = 0;
transform_field (anon_flags, &flags, &flags_output, sizeof (uint16_t));
// TRACEV(std::hex << flags_output);
set_flags (flags_output, output_header);
// TRACEV(std::hex << get_flags (output_header));
// TRACEV(std::hex << output_header->flags__fragment_offset);
// TRACEV(std::hex << ((uint16_t) (flags & 0x07) << 13));
transform_field (anon_ttl, &input_header->ttl, &output_header->ttl, sizeof (uint8_t));
transform_field (anon_protocol, &input_header->protocol, &output_header->protocol, sizeof (uint8_t));
transform_field (anon_source_ip, &input_header->source_ip, &output_header->source_ip, sizeof (in_addr));
transform_field (anon_destination_ip, &input_header->destination_ip, &output_header->destination_ip, sizeof (in_addr));
// if the header length field of packet has too small value, we can't go any further
// TODO anonymize checksum ?!?
if (original_header_length < ip_header_length)
{
set_header_len (original_header_length, output_header);
prepare_output_header (output_header, false);
return ADD_LENGTH_VALUE (error_codes::ip4_header_lenght_value_too_short, ip_header_length);
}
// transform options and set header length
size_t options_length = get_header_len (input_header) - ip_header_length;
size_t new_options_length = transform_field (anon_options, source_buffer + ip_header_length, destination_buffer + ip_header_length, options_length);
uint16_t new_header_length = (uint16_t) (ip_header_length + new_options_length);
set_header_len (new_header_length, output_header);
//TODO fragment offset
// check if this is a fragment, if this is a fragment -> stop transformation
uint16_t fragment_offset = get_fragment_offset(input_header);
set_fragment_offset(fragment_offset, output_header);
if (fragment_offset != 0)
{
prepare_output_header (output_header, true);
return ADD_LENGTH_VALUE(error_codes::ip4_packet_fragmented, ip_header_length);
// TODO call payload transformation?
}
size_t original_payload_length = input_header->total_length - original_header_length;
// transform next layer
const Transformation* next_transformation = Transformation::getTransformationProtocol (transport_protocol);
ssize_t transformed_payload_length = next_transformation->transform (source_buffer + original_header_length, destination_buffer + ip_header_length, original_payload_length);
if (transformed_payload_length < 0)
{
output_header->total_length = (uint16_t (GET_LENGTH_VALUE (transformed_payload_length) + get_header_len (output_header)));
prepare_output_header (output_header, false);
return ADD_LENGTH_VALUE (transformed_payload_length, new_header_length);
}
// set payload length
output_header->total_length = (uint16_t (transformed_payload_length + get_header_len (output_header)));
// if the payload needs to calculate checksum with pseudoheader - feed ip information into it
if (recalculate_payload_checksums && Transformation::hasPseudoHeader (transport_protocol))
{
const PseudoheaderAwareTransformation* p_trans = static_cast (next_transformation);
p_trans->calculate_checksum (
(uint8_t*) &output_header->source_ip, (uint8_t*) &output_header->destination_ip, sizeof (in_addr),
output_header->total_length - ip_header_length, destination_buffer + ip_header_length);
}
prepare_output_header (output_header, recalculate_ipv4_header_checksum);
return new_header_length + transformed_payload_length;
}
pktanon-master/libpktanon/transformations/UdpPacketTransformation.cpp 0000644 0000000 0000000 00000011371 12701423271 025426 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "UdpPacketTransformation.h"
#include "ErrorCodes.h"
#include
#include
#include
#include
using namespace pktanon;
UdpPacketTransformation::~UdpPacketTransformation()
{
delete anon_source_port;
delete anon_destination_port;
}
UdpPacketTransformation::UdpPacketTransformation(AnonPrimitive* anon_source_port, AnonPrimitive* anon_destination_port):
anon_source_port(anon_source_port),
anon_destination_port(anon_destination_port)
{}
static inline void prepare_input_header(UDP_HEADER* input_header)
{
Transformation::ntoh16(input_header->source_port);
Transformation::ntoh16(input_header->destination_port);
Transformation::ntoh16(input_header->length);
Transformation::ntoh16(input_header->checksum);
}
static inline void prepare_output_header(UDP_HEADER* output_header)
{
UdpPacketTransformation::hton16(output_header->source_port);
UdpPacketTransformation::hton16(output_header->destination_port);
UdpPacketTransformation::hton16(output_header->length);
output_header->checksum = 0;
}
int UdpPacketTransformation::transform( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
const size_t udp_header_length = sizeof(UDP_HEADER);
if(unlikely(max_packet_length - udp_header_length < 0)) return error_codes::udp_header_too_short;
UDP_HEADER* input_header = (UDP_HEADER*) source_buffer;
UDP_HEADER* output_header = (UDP_HEADER*) destination_buffer;
prepare_input_header(input_header);
//TODO what to do if max_packet_length < length?
transform_field(anon_source_port, &input_header->source_port, &output_header->source_port, sizeof(uint16_t));
transform_field(anon_destination_port, &input_header->destination_port, &output_header->destination_port, sizeof(uint16_t));
// if input_header->length is bigger than ip payload length than packet is malicious
// don't anonymize further
if (unlikely(input_header->length > max_packet_length)) // length field is length of both header and data!
{
output_header->length = input_header->length;
prepare_output_header(output_header);
return ADD_LENGTH_VALUE(error_codes::udp_header_length_too_long, udp_header_length);
}
const auto payload_transformation = Transformation::getPayloadTransformation();
const size_t new_payload_length = payload_transformation->transform(source_buffer+udp_header_length, destination_buffer+udp_header_length, input_header->length);
output_header->length = udp_header_length + new_payload_length;
prepare_output_header(output_header);
return udp_header_length + new_payload_length;
}
int UdpPacketTransformation::calculate_checksum( uint8_t* source_address, uint8_t* destination_address, unsigned int address_length, uint16_t ip_length, uint8_t* sink_next_header ) const noexcept
{
UDP_HEADER* udp_header = (UDP_HEADER*) sink_next_header;
size_t header_length = sizeof(UDP_HEADER);
size_t udp_length = ntohs(udp_header->length);
size_t payload_length = udp_length - header_length;
assert(udp_header->checksum == 0);
uint16_t padded_protocol = htons(IPPROTO_UDP & 0x00ff);
Checksum checksum;
// source address
checksum.update(source_address, address_length);
// destination address
checksum.update(destination_address, address_length);
// zero, protocol and udp length
checksum.update(&udp_header->length, 2);
checksum.update(&padded_protocol, 2);
// add udp header
checksum.update(udp_header, header_length);
// add packet payload
checksum.update(sink_next_header+header_length, payload_length);
// complete
udp_header->checksum = checksum.final();
// hton16(udp_header->checksum);
return 0;
}
// udp checksum for ipv4:
// pseudoheader:
// 0 7 8 15 16 23 24 31
// +--------+--------+--------+--------+
// | source address |
// +--------+--------+--------+--------+
// | destination address |
// +--------+--------+--------+--------+
// | zero |protocol| UDP length |
// +--------+--------+--------+--------+
// udp packet
// +--------+--------+--------+--------+
// | Source | Destination |
// | Port | Port |
// +--------+--------+--------+--------+
// | | |
// | Length | Checksum |
// +--------+--------+--------+--------+
// |
// | data octets ...
// +---------------- ...
pktanon-master/libpktanon/transformations/PayloadTransformation.h 0000644 0000000 0000000 00000001376 12701423271 024610 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_PAYLOADTRANSFORMATION_H
#define PKTANON_PAYLOADTRANSFORMATION_H
# include "Transformation.h"
namespace pktanon
{
class PayloadTransformation : public Transformation
{
public:
~PayloadTransformation();
PayloadTransformation(AnonPrimitive* payload_anon);
virtual int transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
private:
AnonPrimitive* payload_anon;
};
}
#endif // PKTANON_PAYLOADTRANSFORMATION_H
pktanon-master/libpktanon/transformations/IcmpPacketTransformation.cpp 0000644 0000000 0000000 00000002720 12701423271 025564 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "IcmpPacketTransformation.h"
#include
using namespace pktanon;
IcmpPacketTransformation::~IcmpPacketTransformation()
{
delete anon_type;
delete anon_code;
delete anon_misc;
}
IcmpPacketTransformation::IcmpPacketTransformation(
AnonPrimitive* anon_type,
AnonPrimitive* anon_code,
AnonPrimitive* anon_misc
) :
anon_type(anon_type), anon_code(anon_code),
anon_misc(anon_misc)
{ }
int IcmpPacketTransformation::transform( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
ICMP_HEADER* input_header = (ICMP_HEADER*) source_buffer;
ICMP_HEADER* output_header = (ICMP_HEADER*) destination_buffer;
ntoh32(input_header->misc);
transform_field(anon_type,&input_header->type,&output_header->type,sizeof(uint8_t));
transform_field(anon_code,&input_header->code,&output_header->code,sizeof(uint8_t));
transform_field(anon_misc,&input_header->misc,&output_header->misc,sizeof(uint32_t));
hton32(output_header->misc);
Checksum checksum;
checksum.update(output_header, sizeof(ICMP_HEADER));
output_header->checksum = checksum.final();
// hton16(output_header->checksum);
return sizeof(ICMP_HEADER);
}
pktanon-master/libpktanon/transformations/VlanTagTransformation.cpp 0000644 0000000 0000000 00000004220 12701423271 025075 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "VlanTagTransformation.h"
using namespace pktanon;
VlanTagTransformation::~VlanTagTransformation()
{
delete anon_priority;
delete anon_cfi;
delete anon_vlan_id;
delete anon_type;
}
VlanTagTransformation::VlanTagTransformation (
AnonPrimitive* anon_priority, AnonPrimitive* anon_cfi,
AnonPrimitive* anon_vlan_id, AnonPrimitive* anon_type
) :
anon_priority (anon_priority), anon_cfi (anon_cfi),
anon_vlan_id (anon_vlan_id), anon_type (anon_type)
{}
int VlanTagTransformation::transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
size_t vlan_tag_length = sizeof (VLAN_TAG);
VLAN_TAG* input_header = (VLAN_TAG*) source_buffer;
VLAN_TAG* output_header = (VLAN_TAG*) destination_buffer;
ntoh16 (input_header->priority_cfi_id);
ntoh16 (input_header->type);
uint16_t ethertype = input_header->type;
// priority
uint16_t priority = get_priority (input_header);
uint16_t priority_anon = 0;
transform_field (anon_priority, &priority, &priority_anon, sizeof (uint16_t));
set_priority (output_header, priority_anon);
// cfi
uint16_t cfi = get_cfi (input_header);
uint16_t cfi_anon = 0;
transform_field (anon_cfi, &cfi, &cfi_anon, sizeof (uint16_t));
set_cfi (output_header, cfi_anon);
// vlan_id
uint16_t vlan_id = get_vlan_id (input_header);
uint16_t vlan_id_anon = 0;
transform_field (anon_vlan_id, &vlan_id, &vlan_id_anon, sizeof (uint16_t));
set_vlan_id (output_header, vlan_id);
// (ether)type
transform_field (anon_type, &input_header->type, &output_header->type, sizeof (uint16_t));
const Transformation* next_transformation = Transformation::getTransformationEthertype (ethertype);
vlan_tag_length += next_transformation->transform (source_buffer + vlan_tag_length, destination_buffer + vlan_tag_length, max_packet_length - vlan_tag_length);
return vlan_tag_length;
}
pktanon-master/libpktanon/transformations/ArpPacketTransformation.cpp 0000644 0000000 0000000 00000005432 12701423271 025421 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "transformations/ArpPacketTransformation.h"
#include "ErrorCodes.h"
#include "debug.h"
namespace pktanon
{
ArpPacketTransformation::~ArpPacketTransformation()
{
delete anon_hardware_type;
delete anon_protocol_type;
delete anon_hardware_size;
delete anon_protocol_size;
delete anon_opcode;
delete anon_sender_mac;
delete anon_sender_ip;
delete anon_target_mac;
delete anon_target_ip;
}
ArpPacketTransformation::ArpPacketTransformation(
AnonPrimitive* anon_hardware_type, AnonPrimitive* anon_protocol_type,
AnonPrimitive* anon_hardware_size, AnonPrimitive* anon_protocol_size,
AnonPrimitive* anon_opcode,
AnonPrimitive* anon_sender_mac, AnonPrimitive* anon_sender_ip,
AnonPrimitive* anon_target_mac, AnonPrimitive* anon_target_ip):
anon_hardware_type(anon_hardware_type), anon_protocol_type(anon_protocol_type),
anon_hardware_size(anon_hardware_size), anon_protocol_size(anon_protocol_size),
anon_opcode(anon_opcode),
anon_sender_mac(anon_sender_mac), anon_sender_ip(anon_sender_ip),
anon_target_mac(anon_target_mac), anon_target_ip(anon_target_ip)
{ }
int ArpPacketTransformation::transform( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
if (max_packet_length < sizeof(ARP_HEADER))
{
HB();
return error_codes::arp_packet_too_short;
};
// TODO check hardware_type && hardware_size?
ARP_HEADER* input_header = (ARP_HEADER*) source_buffer;
ARP_HEADER* output_header = (ARP_HEADER*) destination_buffer;
transform_field(anon_hardware_type, &input_header->hardware_type, &output_header->hardware_type, sizeof(uint16_t));
transform_field(anon_protocol_type, &input_header->protocol_type, &output_header->protocol_type, sizeof(uint16_t));
transform_field(anon_hardware_size, &input_header->hardware_size, &output_header->hardware_size, sizeof(uint8_t));
transform_field(anon_protocol_size, &input_header->protocol_size, &output_header->protocol_size, sizeof(uint8_t));
transform_field(anon_opcode, &input_header->opcode, &output_header->opcode, sizeof(uint16_t));
transform_field(anon_sender_mac, &input_header->sender_mac, &output_header->sender_mac, sizeof(MAC_ADDR));
transform_field(anon_sender_ip, &input_header->sender_ip, &output_header->sender_ip, sizeof(in_addr));
transform_field(anon_target_mac, &input_header->target_mac, &output_header->target_mac, sizeof(MAC_ADDR));
transform_field(anon_target_ip, &input_header->target_ip, &output_header->target_ip, sizeof(in_addr));
return sizeof(ARP_HEADER);
}
}
pktanon-master/libpktanon/transformations/ErrorCodes.cpp 0000644 0000000 0000000 00000001247 12701423271 022667 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "ErrorCodes.h"
namespace pktanon
{
const char* const error_strings[][3] =
{
{
"ethernet header too short", 0, 0
},
{
"arp header too short", 0 , 0
},
{
"ip4 header too short", "bogus ip4 header length", "packet is fragmented"
},
{
"ip6 header too short", 0, 0
},
{
"tcp header too short", 0, 0
},
{
"udp header too short", "bad udp length", 0
}
};
}
pktanon-master/libpktanon/transformations/VlanTagTransformation.h 0000644 0000000 0000000 00000003657 12701423271 024557 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_VLANTAGTRANSFORMATION_H
#define PKTANON_VLANTAGTRANSFORMATION_H
# include "Transformation.h"
namespace pktanon
{
# pragma pack (1)
struct VLAN_TAG
{
uint16_t priority_cfi_id;// priority, canonical format identifier, vlan identifier
uint16_t type;// next header, based on ethernet protocol fields
};
# pragma pack ()
class VlanTagTransformation : public Transformation
{
public:
~VlanTagTransformation();
VlanTagTransformation (
AnonPrimitive* anon_priority, AnonPrimitive* anon_cfi,
AnonPrimitive* anon_vlan_id, AnonPrimitive* anon_type
);
virtual int transform (const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
private:
static uint16_t get_priority (VLAN_TAG* header)
{
return ( (header->priority_cfi_id & 0xE000) >> 13);
}
static void set_priority (VLAN_TAG* header, uint16_t priority)
{
header->priority_cfi_id =
(priority & 0xE000) | (header->priority_cfi_id & 0x1FFF);
}
static uint16_t get_cfi (VLAN_TAG* header)
{
return ( (header->priority_cfi_id & 0x1000) != 0);
}
static void set_cfi (VLAN_TAG* header, uint16_t cfi)
{
header->priority_cfi_id =
(cfi & 0x1000) | (header->priority_cfi_id & 0xEFFF);
}
static uint16_t get_vlan_id (VLAN_TAG* header)
{
return (header->priority_cfi_id & 0x0FFF);
}
static void set_vlan_id (VLAN_TAG* header, uint16_t vlan_id)
{
header->priority_cfi_id =
(vlan_id & 0x0FFF) | (header->priority_cfi_id & 0xF000);
}
AnonPrimitive* anon_priority;
AnonPrimitive* anon_cfi;
AnonPrimitive* anon_vlan_id;
AnonPrimitive* anon_type;
};
}
#endif // PKTANON_VLANTAGTRANSFORMATION_H
pktanon-master/libpktanon/transformations/IPv6PacketTransformation.h 0000644 0000000 0000000 00000005536 12701423271 025135 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_IPV6PACKETTRANSFORMATION_H
#define PKTANON_IPV6PACKETTRANSFORMATION_H
# include "Transformation.h"
namespace pktanon
{
struct IPv6_HEADER
{
uint32_t version__traffic_class__flow_label; // configuration item Ipv6Trafficclass and Ipv6Flowlabel
uint16_t payload_length;
uint8_t next_header;
uint8_t hop_limit; // configuration item Ipv6Hoplimit
in6_addr source_addr; // configuration item Ipv6Sourceaddr
in6_addr destination_addr; // configuration item Ipv6Destaddr
};
class IPv6PacketTransformation : public Transformation
{
public:
~IPv6PacketTransformation();
IPv6PacketTransformation(
AnonPrimitive* anon_traffic_class,
AnonPrimitive* anon_flow_label,
AnonPrimitive* anon_next_header,
AnonPrimitive* anon_hop_limit,
AnonPrimitive* anon_source_addr,
AnonPrimitive* anon_destination_addr,
bool recalculate_payload_checksums
);
virtual int transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
private:
static uint32_t get_version(IPv6_HEADER* header)
{
return (header->version__traffic_class__flow_label & 0xF0000000) >> 28;
}
static void set_version(uint32_t version, IPv6_HEADER* header)
{
header->version__traffic_class__flow_label =
((version & 0xF) << 28) | (header->version__traffic_class__flow_label & 0x0FFFFFFF);
}
static uint32_t get_traffic_class(IPv6_HEADER* header)
{
return (header->version__traffic_class__flow_label & 0x0FF00000) >> 20;
};
static void set_traffic_class(uint32_t traffic_class, IPv6_HEADER* header)
{
header->version__traffic_class__flow_label =
((traffic_class << 20) & 0x0FF00000) | (header->version__traffic_class__flow_label & 0xF00FFFFF);
}
static uint32_t get_flow_label(IPv6_HEADER* header)
{
return (header->version__traffic_class__flow_label & 0x000FFFFF);
};
static void set_flow_label(uint32_t flow_label, IPv6_HEADER* header)
{
header->version__traffic_class__flow_label =
(flow_label & 0x000FFFFF) | (header->version__traffic_class__flow_label & 0xFFF00000);
};
const AnonPrimitive* const anon_traffic_class;
const AnonPrimitive* const anon_flow_label;
const AnonPrimitive* const anon_next_header;
const AnonPrimitive* const anon_hop_limit;
const AnonPrimitive* const anon_source_addr;
const AnonPrimitive* const anon_destination_addr;
const bool recalculate_payload_checksums;
};
}
#endif // PKTANON_IPV6PACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/UdpLitePacketTransformation.cpp 0000644 0000000 0000000 00000004523 12701423271 026245 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "UdpLitePacketTransformation.h"
using namespace pktanon;
UdpLitePacketTransformation::~UdpLitePacketTransformation()
{
delete anon_source_port;
delete anon_destination_port;
delete anon_checksum_coverage;
}
UdpLitePacketTransformation::UdpLitePacketTransformation(
AnonPrimitive* anon_source_port,
AnonPrimitive* anon_destination_port,
AnonPrimitive* anon_checksum_coverage):
anon_source_port(anon_source_port),
anon_destination_port(anon_destination_port),
anon_checksum_coverage(anon_checksum_coverage)
{ }
size_t UdpLitePacketTransformation::transform(uint8_t* source_buffer, uint8_t* destination_buffer) const
{
UDPLITE_HEADER* input_header = (UDPLITE_HEADER*) source_buffer;
UDPLITE_HEADER* output_header = (UDPLITE_HEADER*) destination_buffer;
ntoh16(input_header->source_port);
ntoh16(input_header->destination_port);
ntoh16(input_header->checksum_coverage);
transform_field(anon_source_port, &input_header->source_port, &output_header->source_port, sizeof(uint16_t));
transform_field(anon_destination_port, &input_header->destination_port, &output_header->destination_port, sizeof(uint16_t));
transform_field(anon_checksum_coverage, &input_header->checksum_coverage, &output_header->checksum_coverage, sizeof(uint16_t));
output_header->checksum = 0;
auto payload_transformation = Transformation::getPayloadTransformation();
size_t new_payload_length = payload_transformation->transform(source_buffer+sizeof(UDPLITE_HEADER), destination_buffer+sizeof(UDPLITE_HEADER));
uint16_t new_packet_length = sizeof(UDPLITE_HEADER) + new_payload_length;
//checksum coverage must be at least header
output_header->checksum_coverage = std::max (output_header->checksum_coverage, sizeof(UDPLITE_HEADER));
// checksum_coverage must be smaller than packet length
output_header->checksum_coverage = std::min(output_header->checksum_coverage, new_packet_length);
hton16(output_header->source_port);
hton16(output_header->destination_port);
hton16(output_header->checksum_coverage);
return sizeof(UDPLITE_HEADER) + new_payload_length;
}
pktanon-master/libpktanon/transformations/EthernetPacketTransformation.cpp 0000644 0000000 0000000 00000005321 12701423271 026452 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "EthernetPacketTransformation.h"
#include "ErrorCodes.h"
//-----------------------------------------------------------------------------
#include "optmacros.h"
#include "debug.h"
namespace pktanon
{
EthernetPacketTransformation::~EthernetPacketTransformation()
{
delete anon_dest_mac;
delete anon_source_mac;
delete anon_ethertype;
};
EthernetPacketTransformation::EthernetPacketTransformation (pktanon::AnonPrimitive* anon_dest_mac, pktanon::AnonPrimitive* anon_source_mac, pktanon::AnonPrimitive* anon_ethertype, pktanon::EthernetPacketTransformation::PAD pad_mode) :
anon_dest_mac (anon_dest_mac),
anon_source_mac (anon_source_mac),
anon_ethertype (anon_ethertype),
pad_mode (pad_mode)
{}
int EthernetPacketTransformation::transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
const size_t ether_header_len = sizeof (ETHERNET_HEADER);
if (unlikely (max_packet_length < ether_header_len))
{
return error_codes::ethernet_header_too_short;
}
ETHERNET_HEADER* input_header = (ETHERNET_HEADER*) source_buffer;
ETHERNET_HEADER* output_header = (ETHERNET_HEADER*) destination_buffer;
ntoh16 (input_header->type);
const uint16_t ether_type = input_header->type;
transform_field (anon_dest_mac, &input_header->destination, &output_header->destination, sizeof (MAC_ADDR));
transform_field (anon_source_mac, &input_header->source, &output_header->source, sizeof (MAC_ADDR));
transform_field (anon_ethertype, &input_header->type, &output_header->type, sizeof (uint16_t));
hton16 (output_header->type);
const Transformation* next_transformation = Transformation::getTransformationEthertype (ether_type);
ssize_t payload_len = next_transformation->transform (
source_buffer + ether_header_len,
destination_buffer + ether_header_len,
max_packet_length - ether_header_len);
if (unlikely (payload_len < 0)) return ADD_LENGTH_VALUE (payload_len, ether_header_len);
if (pad_mode != PAD::NEVER)
{
// TODO? here we should pad to the minimum 46 length, but if the original
// packet is smaller than 46, than padding can create overflow in the
// destination_buffer.
if (payload_len < 46 && ( pad_mode == PAD::ALWAYS || (max_packet_length >= ether_header_len + 46)))
{
payload_len = 46;
}
}
return ether_header_len + payload_len;
}
}
pktanon-master/libpktanon/transformations/UdpLitePacketConfigurator.h 0000644 0000000 0000000 00000000747 12701423271 025352 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_UDPLITEPACKETCONFIGURATOR_H
#define PKTANON_UDPLITEPACKETCONFIGURATOR_H
namespace pktanon
{
class UdpLitePacketConfigurator
{
public:
static void
};
}
#endif // PKTANON_UDPLITEPACKETCONFIGURATOR_H
pktanon-master/libpktanon/transformations/IPv6PacketTransformation.cpp 0000644 0000000 0000000 00000010622 12701423271 025460 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "IPv6PacketTransformation.h"
#include "PseudoheaderAwareTransformation.h"
#include "ErrorCodes.h"
#include "optmacros.h"
#include "debug.h"
using namespace pktanon;
IPv6PacketTransformation::~IPv6PacketTransformation()
{
delete anon_traffic_class;
delete anon_flow_label;
delete anon_hop_limit;
delete anon_source_addr;
delete anon_destination_addr;
}
IPv6PacketTransformation::IPv6PacketTransformation (
AnonPrimitive* anon_traffic_class,
AnonPrimitive* anon_flow_label,
AnonPrimitive* anon_next_header,
AnonPrimitive* anon_hop_limit,
AnonPrimitive* anon_source_addr,
AnonPrimitive* anon_destination_addr,
bool recalculate_payload_checksums
) :
anon_traffic_class ( anon_traffic_class ),
anon_flow_label ( anon_flow_label ),
anon_next_header ( anon_next_header ),
anon_hop_limit ( anon_hop_limit ),
anon_source_addr ( anon_source_addr ),
anon_destination_addr ( anon_destination_addr ),
recalculate_payload_checksums ( recalculate_payload_checksums )
{
}
int IPv6PacketTransformation::transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
const size_t ipv6_header_length = sizeof ( IPv6_HEADER );
if ( unlikely ( max_packet_length < ipv6_header_length ) ) return error_codes::ip6_header_too_short;
IPv6_HEADER* input_header = ( IPv6_HEADER* ) source_buffer;
IPv6_HEADER* output_header = ( IPv6_HEADER* ) destination_buffer;
const uint8_t next_header = input_header->next_header;
ntoh32 ( input_header->version__traffic_class__flow_label );
ntoh16 ( input_header->payload_length );
//version is always 6
set_version ( 6u, output_header );
//anonymize traffic class
uint32_t input_traffic_class = get_traffic_class ( input_header );
uint32_t output_traffic_class = 0;
transform_field ( anon_traffic_class, &input_traffic_class, &output_traffic_class, sizeof ( uint32_t ) );
set_traffic_class ( output_traffic_class, output_header );
//anonymize flow label
uint32_t input_flow_label = get_flow_label ( input_header );
uint32_t output_flow_label = 0;
transform_field ( anon_flow_label, &input_flow_label, &output_flow_label, sizeof ( uint32_t ) );
set_flow_label ( output_flow_label, output_header );
//payload_length is recalculated below
//rest of the fields
transform_field ( anon_next_header, &input_header->next_header, &output_header->next_header, sizeof ( uint8_t ) );
transform_field ( anon_hop_limit, &input_header->hop_limit, &output_header->hop_limit, sizeof ( uint8_t ) );
transform_field ( anon_source_addr, &input_header->source_addr, &output_header->source_addr, sizeof ( in6_addr ) );
transform_field ( anon_destination_addr, &input_header->destination_addr, &output_header->destination_addr, sizeof ( in6_addr ) );
// payload
size_t payload_length;
const Transformation* next_transformation;
next_transformation = Transformation::getTransformationProtocol ( next_header );
payload_length = next_transformation->transform ( source_buffer + ipv6_header_length, destination_buffer + ipv6_header_length, input_header->payload_length );
if ( payload_length < 0 )
{
output_header->payload_length = GET_LENGTH_VALUE ( payload_length );
hton32 ( output_header->version__traffic_class__flow_label );
hton16 ( output_header->payload_length );
return ADD_LENGTH_VALUE ( payload_length, ipv6_header_length );
};
output_header->payload_length = payload_length;
// if the payload needs to calculate checksum with pseudoheader - feed ip information into it
if ( recalculate_payload_checksums && Transformation::hasPseudoHeader ( next_header ) )
{
const PseudoheaderAwareTransformation* p_trans = static_cast ( next_transformation );
p_trans->calculate_checksum (
( uint8_t* ) &output_header->source_addr, ( uint8_t* ) &output_header->destination_addr, sizeof ( in6_addr ),
output_header->payload_length, destination_buffer + ipv6_header_length );
}
hton32 ( output_header->version__traffic_class__flow_label );
hton16 ( output_header->payload_length );
return ipv6_header_length + payload_length;
}
pktanon-master/libpktanon/transformations/ICMPv6PacketTransformation.cpp 0000644 0000000 0000000 00000010356 12701423271 025704 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "ICMPv6PacketTransformation.h"
#include
#include
using namespace pktanon;
ICMPv6PacketTransformation::~ICMPv6PacketTransformation()
{
delete anon_type;
delete anon_code;
delete anon_misc;
delete anon_target_address;
}
ICMPv6PacketTransformation::ICMPv6PacketTransformation (
AnonPrimitive* anon_type, AnonPrimitive* anon_code, AnonPrimitive* anon_misc, AnonPrimitive* anon_target_address
) :
anon_type (anon_type), anon_code (anon_code), anon_misc (anon_misc),
anon_target_address (anon_misc)
{ }
int ICMPv6PacketTransformation::transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
if (max_packet_length < sizeof (ICMPv6_HEADER)) return -1;
ICMPv6_HEADER* input_header = (ICMPv6_HEADER*) source_buffer;
ICMPv6_HEADER* output_header = (ICMPv6_HEADER*) destination_buffer;
uint8_t type = input_header->type;
transform_field (anon_type, &input_header->type, &output_header->type, sizeof (uint8_t));
transform_field (anon_code, &input_header->code, &output_header->code, sizeof (uint8_t));
size_t message_length = 0;
if (type == ICMPv6_Types::NDP_NSM)
{
message_length += nsm_transform (source_buffer + sizeof (uint32_t), destination_buffer + sizeof (uint32_t), max_packet_length - sizeof (uint32_t));
}
else if (type == ICMPv6_Types::NDP_NAM)
{
message_length += nam_transform (source_buffer + sizeof (uint32_t), destination_buffer + sizeof (uint32_t), max_packet_length - sizeof (uint32_t));
}
else
{
transform_field (anon_misc, &input_header->misc, &output_header->misc, sizeof (uint32_t));
message_length = sizeof (uint32_t);
}
if (message_length < 0) return message_length;
// Checksum checksum;
// output_header->checksum = 0;
// checksum.update(destination_buffer, sizeof(uint32_t) + message_length);
// output_header->checksum = checksum.final();
//
// hton16(output_header->checksum);
return sizeof (ICMPv6_HEADER) + message_length;
}
int ICMPv6PacketTransformation::nam_transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const
{
if (max_packet_length < sizeof (ICMPv6_NAM_HEADER)) return -1;
ICMPv6_NAM_HEADER* input_header = (ICMPv6_NAM_HEADER*) source_buffer;
ICMPv6_NAM_HEADER* output_header = (ICMPv6_NAM_HEADER*) destination_buffer;
// TODO what to do with RSO?
output_header->rso__reserved = 0;
transform_field (anon_target_address, &input_header->target_address, &output_header->target_address, sizeof (in6_addr));
return sizeof (ICMPv6_NAM_HEADER);
}
int ICMPv6PacketTransformation::nsm_transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const
{
if (max_packet_length < sizeof (ICMPv6_NSM_HEADER)) return -1;
ICMPv6_NSM_HEADER* input_header = (ICMPv6_NSM_HEADER*) source_buffer;
ICMPv6_NSM_HEADER* output_header = (ICMPv6_NSM_HEADER*) destination_buffer;
output_header->reserved = 0;
transform_field (anon_target_address, &input_header->target_address, &output_header->target_address, sizeof (in6_addr));
return sizeof (ICMPv6_NSM_HEADER);
}
int ICMPv6PacketTransformation::calculate_checksum ( uint8_t* source_address, uint8_t* destination_address, unsigned int address_length, uint16_t ip_length, uint8_t* sink_next_header ) const noexcept
{
ICMPv6_HEADER* output_header = (ICMPv6_HEADER*) sink_next_header;
// set checksum to 0
output_header->checksum = 0;
Checksum checksum;
// IPv6 pseudoheader
checksum.update (source_address, address_length);
checksum.update (destination_address, address_length);
checksum.update (&ip_length, sizeof (uint16_t));
uint16_t padded_protocol = htons (IPPROTO_ICMPV6 & 0x00ff);
checksum.update (&padded_protocol, sizeof (uint16_t));
// icmp6 packet of length as in ipv6 header
checksum.update(sink_next_header, ip_length);
// get final checksum
output_header->checksum = checksum.final();
hton16 (output_header->checksum);
return 0;
}
pktanon-master/libpktanon/transformations/ErrorCodes.h 0000644 0000000 0000000 00000003717 12701423271 022340 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
# ifndef PKTANON__ERRORCODES_H
# define PKTANON__ERRORCODES_H
namespace pktanon
{
/**
* error code structure: left-most bit '1' to indicate negative value, next 7 bits are packet number, next 8 bits
* is error code within the packet, next 2 / 6 bytes is length of the transformed value.
*
* this is a preparation for dynamically adding error codes in TransformationConfigurator
*/
extern const char* const error_strings[][3];
enum error_codes : int
{
ethernet_header_too_short = 0x8000 << sizeof ( int ) * 8 - 16,
arp_packet_too_short = 0x8100 << sizeof ( int ) * 8 - 16,
ip4_header_too_short = 0x8200 << sizeof ( int ) * 8 - 16,
ip4_header_lenght_value_too_short = 0x8201 << sizeof ( int ) * 8 - 16,
ip4_packet_fragmented = 0x8202 << sizeof ( int ) * 8 - 16,
ip6_header_too_short = 0x8300 << sizeof ( int ) * 8 - 16,
tcp_header_too_short = 0x8400 << sizeof ( int ) * 8 - 16,
udp_header_too_short = 0x8500 << sizeof ( int ) * 8 - 16,
udp_header_length_too_long = 0x8501 << sizeof ( int ) * 8 - 16,
linux_llc_header_too_short = 0x8600 << sizeof ( int ) * 8 - 16,
};
inline long int GET_ERROR_CODE ( long int error_value )
{
return error_value >> sizeof ( int ) * 8 - 16;
}
inline const char* GET_ERROR_STRING ( int error_value )
{
auto pkt_error_code = error_value >> sizeof ( int ) * 8 - 16;
auto pkt = ( pkt_error_code >> 8 ) & 0x6f;
auto error_code = pkt_error_code & 0xff;
return error_strings[pkt][error_code];
}
inline int GET_LENGTH_VALUE ( int error_value )
{
return error_value & 0xffff;
}
inline int ADD_LENGTH_VALUE ( int error_value, unsigned int length_value )
{
// assume that length_value < max_short
return error_value + length_value;
}
}
# endif
pktanon-master/libpktanon/transformations/IcmpPacketTransformation.h 0000644 0000000 0000000 00000002020 12701423271 025222 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_ICMPPACKETTRANSFORMATION_H
#define PKTANON_ICMPPACKETTRANSFORMATION_H
# include "Transformation.h"
namespace pktanon
{
# pragma pack (1)
struct ICMP_HEADER
{
uint8_t type;
uint8_t code;
uint16_t checksum;
uint32_t misc;
} ;
# pragma pack ()
class IcmpPacketTransformation : public Transformation
{
public:
virtual ~IcmpPacketTransformation();
IcmpPacketTransformation(
AnonPrimitive* anon_type,
AnonPrimitive* anon_code,
AnonPrimitive* anon_misc
);
virtual int transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
private:
AnonPrimitive* anon_type;
AnonPrimitive* anon_code;
AnonPrimitive* anon_misc;
};
}
#endif // PKTANON_ICMPPACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/DefaultTransformationsConfigurator.h 0000644 0000000 0000000 00000003621 12701423271 027344 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__DEFAULTTRANSFORMATIONSCONFIGURATOR_H
#define PKTANON__DEFAULTTRANSFORMATIONSCONFIGURATOR_H
#include
namespace pktanon
{
class DefaultTransformationsConfigurator
{
public:
static void configure_ethernet_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_vlan_tag(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_linux_sll_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_arp_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_ipv4_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_ipv6_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_icmp_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_icmpv6_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_tcp_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_udp_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
static void configure_payload_packet(const PktAnonConfig::PacketConfig& packet_config, const pktanon::PktAnonConfig& config);
};
}
#endif // PKTANON_DEFAULTTRANSFORMATIONSCONFIGURATOR_H
pktanon-master/libpktanon/transformations/TcpPacketTransformation.h 0000644 0000000 0000000 00000005735 12701423271 025100 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_TCPPACKETTRANSFORMATION_H
#define PKTANON_TCPPACKETTRANSFORMATION_H
# include "transformations/PseudoheaderAwareTransformation.h"
namespace pktanon
{
# pragma pack (1)
struct TCP_HEADER
{
uint16_t source_port; // source port. configuration item TcpSourceport
uint16_t dest_port; // destination port. configuration item TcpDestport
uint32_t seq_num; // sequence number. configuration item TcpSeqnum
uint32_t ack_num; // acknowledgement number. configuration item TcpAcknum
uint16_t header_len__flags; //header length 4 bit, 6 bit reserved, 6 bit flags. configuration item TcpFlags. none for header length
uint16_t window_size; // window size. configuration item TcpWindowsize
uint16_t checksum; // checksum
uint16_t urgent_pointer; // urgent pointer. configuration item TcpUrgentpnt
};
# pragma pack ()
class TcpPacketTransformation : public PseudoheaderAwareTransformation
{
public:
virtual ~TcpPacketTransformation();
TcpPacketTransformation(
AnonPrimitive* anon_source_port, AnonPrimitive* anon_dest_port,
AnonPrimitive* anon_seq_num,
AnonPrimitive* anon_ack_num,
AnonPrimitive* anon_flags, AnonPrimitive* anon_window_size,
AnonPrimitive* anon_urgent_pointer,
AnonPrimitive* anon_options
);
virtual int transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
virtual int calculate_checksum(uint8_t* source_address, uint8_t* destination_address, unsigned address_length, uint16_t length, uint8_t* sink_next_header) const noexcept;
private:
static uint16_t get_header_len(TCP_HEADER* header)
{
return (((header->header_len__flags & 0xF000) >> 12) << 2);
}
static void set_header_len(uint16_t header_len, TCP_HEADER* header)
{
header->header_len__flags = (((header_len / 4) & 0xF) << 12) | (get_flags(header) & 0x3F);
}
static uint16_t get_flags(TCP_HEADER* header)
{
return ((header->header_len__flags & 0x3F ));
}
static void set_flags(uint16_t flags, TCP_HEADER* header)
{
header->header_len__flags =
(((get_header_len(header) / 4) & 0xF) << 12) | (flags & 0x3F);
}
AnonPrimitive* anon_source_port;
AnonPrimitive* anon_dest_port;
AnonPrimitive* anon_seq_num;
AnonPrimitive* anon_ack_num;
AnonPrimitive* anon_flags;
AnonPrimitive* anon_window_size;
AnonPrimitive* anon_urgent_pointer;
AnonPrimitive* anon_options;
};
}
#endif // PKTANON_TCPPACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/TransformationsConfigurator.cpp 0000644 0000000 0000000 00000012155 12701423271 026374 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "TransformationsConfigurator.h"
//----------------------------------------------------------------------------------------------
#include "AnonFactory.h"
#include "anonprimitives/AnonPrimitive.h"
#include "transformations/PseudoheaderAwareTransformation.h"
#include
#include
#include "log.h"
#include "debug.h"
using namespace pktanon;
TransformationsConfigurator& TransformationsConfigurator::instance()
{
static TransformationsConfigurator tc;
return tc;
}
void TransformationsConfigurator::register_configurator(std::string config_name, TransformationsConfigurator::Configurator configurator)
{
instance().supported_packets.emplace(config_name, configurator);
}
void TransformationsConfigurator::configure_packet_transformations( const PktAnonConfig& config )
{
// PRINT("REGISTERED PACKETS[" << supported_packets.size() << "]");
// for (auto& packet:supported_packets)
// PRINT(packet.first);
for (const auto& packet_config: config.get_packets())
{
auto it = supported_packets.find(packet_config.get_protocol());
if (it != supported_packets.end())
{
(*it).second(packet_config, config);
}
else
{
_plg_error("unknown packet: " << packet_config.get_protocol());
}
}
}
void TransformationsConfigurator::configure_transformations_lookups()
{
//TODO remove me!
if (!payload_transformation)
{
throw std::runtime_error("payload packet must be configured");
}
// linktype lookup is done only once, so just copy the data there
Transformation::linktype_lookup_table = std::move(included_linktypes);
// configure lookup by ethertype
{
size_t table_size;
auto hash_fn = generate_phf(included_ethertypes, table_size);
PHT ethetype_lookup_table(hash_fn, table_size);
for (auto included_ethertype : included_ethertypes)
{
ethetype_lookup_table.insert(included_ethertype.first, included_ethertype.second);
}
Transformation::ethetype_lookup_table =std::move(ethetype_lookup_table); //!MOVE!
}
//configure lookup by protocol
{
std::unordered_map checksum_protocols;
checksum_protocols.reserve(included_protocols.size());
for (auto included_protocol : included_protocols)
{
if (dynamic_cast(included_protocol.second) != nullptr)
{
checksum_protocols.emplace(included_protocol.first, included_protocol.second);
}
}
// IPv6 Hop-by-Hop Option has proto value 0 and is not checksum aware
// p is 31, the value 31 * 16 is not valid proto value and will map to 0
checksum_protocols.emplace(prime * 16, nullptr);
size_t table_size;
size_t cp_table_size;
auto hash_fn = generate_phf(included_protocols, table_size);
auto cp_hash_fn = generate_phf(checksum_protocols, cp_table_size);
PHT protocol_lookup_table(hash_fn, table_size);
PHT checksums_lookup_table(cp_hash_fn, cp_table_size);
for (auto included_protocol : included_protocols)
{
protocol_lookup_table.insert(included_protocol.first, included_protocol.second);
// TRACEV((int)included_protocol.first);
// if (dynamic_cast(included_protocol.second) != nullptr)
// {
// checksums_lookup_table.insert(included_protocol.first, true);
// }
}
for (auto checksum_protocol : checksum_protocols)
{
checksums_lookup_table.insert(checksum_protocol.first, true);
// TRACEV(checksum_protocol.first);
// TRACEV(cp_hash_fn(checksum_protocol.first));
}
// TRACEV(cp_hash_fn(0));
Transformation::protocol_lookup_table = std::move(protocol_lookup_table);
Transformation::checksums_lookup_table = std::move(checksums_lookup_table);
}
// add payload packet
Transformation::payloadTransformation = payload_transformation;
}
AnonPrimitive* TransformationsConfigurator::configure_packet_field(const string& field, const PktAnonConfig::PacketConfig& packet_config)
{
if (!packet_config.has_field(field)) return nullptr;
auto& anons_config = packet_config.get_anon_config(field);
if (anons_config.size() == 0) throw std::runtime_error("empty configuration for field: " + field); //TODO exception or nullptr
_plg_verbose ("\t\t" << field << "[0]: " << anons_config[0].get_anon_class());
AnonPrimitive* first = AnonFactory::create_anon(anons_config[0].get_anon_class(), anons_config[0].get_anon_params());
AnonPrimitive* prev = first;
for (int j = 1; j < anons_config.size() ; j++)
{
_plg_verbose("\t\t" << field << "[" << j <<"]: " << anons_config[j].get_anon_class());
AnonPrimitive* next = AnonFactory::create_anon(anons_config[j].get_anon_class(), anons_config[j].get_anon_params());
prev->setNext(next);
prev = next;
}
return first;
}
pktanon-master/libpktanon/transformations/LinuxCookedCaptureTransformation.cpp 0000644 0000000 0000000 00000005547 12701423271 027326 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "LinuxCookedCaptureTransformation.h"
#include "optmacros.h"
#include "transformations/ErrorCodes.h"
#include
using namespace pktanon;
LinuxCookedCaptureTransformation::LinuxCookedCaptureTransformation(
AnonPrimitive* anon_packet_type, AnonPrimitive* anon_hardware_type,
AnonPrimitive* anon_link_layer_addr, AnonPrimitive* anon_protocol_type
) :
anon_packet_type(anon_packet_type), anon_hardware_type(anon_hardware_type),
anon_link_layer_addr(anon_link_layer_addr), anon_protocol_type(anon_protocol_type)
{ }
int LinuxCookedCaptureTransformation::transform( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
const size_t linux_sll_header_len = sizeof (LINUX_SLL_HEADER);
if (unlikely (max_packet_length < linux_sll_header_len))
{
return error_codes::linux_llc_header_too_short;
}
LINUX_SLL_HEADER* input_header = (LINUX_SLL_HEADER*) source_buffer;
LINUX_SLL_HEADER* output_header = (LINUX_SLL_HEADER*) destination_buffer;
// network->host byteorder
ntoh16(input_header->packet_type);
ntoh16(input_header->hardware_type);
ntoh16(input_header->link_layer_addr_len);
ntoh16(input_header->protocol_type);
const uint16_t ether_type = input_header->protocol_type;
// anonymize packet
transform_field (anon_packet_type, &input_header->packet_type, &output_header->packet_type, sizeof (uint16_t));
transform_field (anon_hardware_type,&input_header->hardware_type, &output_header->hardware_type, sizeof (uint16_t));
output_header->link_layer_addr_len = transform_field (anon_link_layer_addr,&input_header->link_layer_addr,&output_header->link_layer_addr, std::min((uint16_t)8, input_header->link_layer_addr_len));
transform_field (anon_protocol_type, &input_header->protocol_type, &output_header->protocol_type, sizeof (uint16_t));
// host->network byteorder
hton16(output_header->packet_type);
hton16(output_header->hardware_type);
hton16(output_header->link_layer_addr_len);
hton16(output_header->protocol_type);
// call next transformation
const Transformation* next_transformation = Transformation::getTransformationEthertype (ether_type);
ssize_t payload_len = next_transformation->transform (
source_buffer + linux_sll_header_len,
destination_buffer + linux_sll_header_len,
max_packet_length - linux_sll_header_len);
if (unlikely (payload_len < 0)) return ADD_LENGTH_VALUE (payload_len, linux_sll_header_len);
return linux_sll_header_len + payload_len;
}
pktanon-master/libpktanon/transformations/Transformation.cpp 0000644 0000000 0000000 00000001667 12701423271 023634 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "Transformation.h"
#include
namespace pktanon
{
Transformation::~Transformation() = default;
std::unordered_map Transformation::linktype_lookup_table;
PHT Transformation::ethetype_lookup_table;
PHT Transformation::protocol_lookup_table;
PHT Transformation::checksums_lookup_table;
Transformation* Transformation::payloadTransformation = nullptr;
Transformation* Transformation::getTransformationLinktype(uint32_t linktype)
{
auto iter = linktype_lookup_table.find(linktype);
if (iter != linktype_lookup_table.end()) return (*iter).second;
return nullptr;
}
}
pktanon-master/libpktanon/transformations/ArpPacketTransformation.h 0000644 0000000 0000000 00000005011 12701423271 025057 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ARPPACKETTRANSFORMATION_H
#define PKTANON__ARPPACKETTRANSFORMATION_H
#include "Transformation.h"
#include
#include
namespace pktanon
{
# pragma pack (1)
struct ARP_HEADER
{
uint16_t hardware_type; // 0x0001 for ethernet. configuration item ArpHardwaretp
uint16_t protocol_type; // 0x0800 for ip. configuration item ArpPrototp
uint8_t hardware_size; // 0x6 for ethernet mac addressess. configuration item ArpHardwareaddrlen
uint8_t protocol_size; // 0x4 for ip addresses. configuration item ArpProtoaddrlen
uint16_t opcode; // see defines below. configuration item ArpOpcode
MAC_ADDR sender_mac; // configuration item ArpSourcemac
in_addr sender_ip; // configuration item ArpSourceip
MAC_ADDR target_mac; // configuration item ArpDestmac
in_addr target_ip; // configuration item ArpDestip
};
# pragma pack ()
class ArpPacketTransformation : public Transformation
{
public:
~ArpPacketTransformation();
ArpPacketTransformation (
AnonPrimitive* anon_hardware_type, AnonPrimitive* anon_protocol_type,
AnonPrimitive* anon_hardware_size, AnonPrimitive* anon_protocol_size,
AnonPrimitive* anon_opcode,
AnonPrimitive* anon_sender_mac, AnonPrimitive* anon_sender_ip,
AnonPrimitive* anon_target_mac, AnonPrimitive* anon_target_ip
);
virtual int transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length ) const noexcept;
private:
const AnonPrimitive* const anon_hardware_type;
const AnonPrimitive* const anon_protocol_type;
const AnonPrimitive* const anon_hardware_size;
const AnonPrimitive* const anon_protocol_size;
const AnonPrimitive* const anon_opcode;
const AnonPrimitive* const anon_sender_mac;
const AnonPrimitive* const anon_sender_ip;
const AnonPrimitive* const anon_target_mac;
const AnonPrimitive* const anon_target_ip;
};
}
#endif // PKTANON_ARPPACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/TransformationsConfigurator.h 0000644 0000000 0000000 00000004522 12701423271 026040 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_TRANSFORMATIONCONFIGURATOR_H
#define PKTANON_TRANSFORMATIONCONFIGURATOR_H
# include
# include
# include
# include
namespace pktanon
{
#define REGISTER_PACKET(PACKET, FUNC) \
TransformationsConfigurator::regger PACKET##regger(#PACKET, FUNC);
class AnonPrimitive;
class Transformation;
class TransformationsConfigurator
{
public:
typedef std::function Configurator;
static TransformationsConfigurator& instance();
// static void destroy();
static void register_configurator(std::string config_name, Configurator configurator);
struct regger { regger(std::string config_name, Configurator configurator) { register_configurator(config_name, configurator);}; };
private:
TransformationsConfigurator() : payload_transformation(nullptr) {};
//----------------------------------------
public:
void configure_packet_transformations(const PktAnonConfig& config);
void configure_transformations_lookups();
void add_linktype(uint32_t linktype, Transformation* trans) {included_linktypes.emplace(linktype, trans);};
void add_ethertype(uint16_t ethertype, Transformation* trans) {included_ethertypes.emplace(ethertype, trans);};
void add_protocol(uint8_t protocol, Transformation* trans) {included_protocols.emplace(protocol, trans);};
void add_payload_transformation(Transformation* payload_transformation) {this->payload_transformation = payload_transformation;};
public:
static AnonPrimitive* configure_packet_field(const std::string& field, const PktAnonConfig::PacketConfig& packet_config);
private:
static TransformationsConfigurator* _instance;
std::unordered_map supported_packets;
std::unordered_map included_linktypes;
std::unordered_map included_ethertypes;
std::unordered_map included_protocols;
Transformation* payload_transformation;
};
}
#endif // PKTANON_TRANSFORMATIONCONFIGURATOR_H
pktanon-master/libpktanon/transformations/TcpPacketTransformation.cpp 0000644 0000000 0000000 00000014766 12701423271 025437 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "TcpPacketTransformation.h"
#include "ErrorCodes.h"
#include "Checksum.h"
#include "debug.h"
using namespace pktanon;
TcpPacketTransformation::~TcpPacketTransformation()
{
delete anon_source_port;
delete anon_dest_port;
delete anon_seq_num;
delete anon_ack_num;
delete anon_flags;
delete anon_window_size;
delete anon_urgent_pointer;
delete anon_options;
}
TcpPacketTransformation::TcpPacketTransformation (
AnonPrimitive* anon_source_port, AnonPrimitive* anon_dest_port,
AnonPrimitive* anon_seq_num,
AnonPrimitive* anon_ack_num,
AnonPrimitive* anon_flags, AnonPrimitive* anon_window_size,
AnonPrimitive* anon_urgent_pointer,
AnonPrimitive* anon_options
) :
anon_source_port (anon_source_port), anon_dest_port (anon_dest_port),
anon_seq_num (anon_seq_num),
anon_ack_num (anon_ack_num),
anon_flags (anon_flags), anon_window_size (anon_window_size),
anon_urgent_pointer (anon_urgent_pointer),
anon_options (anon_options)
{ }
int TcpPacketTransformation::transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length ) const noexcept
{
size_t tcp_header_length = sizeof (TCP_HEADER);
if (max_packet_length < tcp_header_length) return error_codes::tcp_header_too_short;
TCP_HEADER* input_header = (TCP_HEADER*) source_buffer;
TCP_HEADER* output_header = (TCP_HEADER*) destination_buffer;
ntoh16 (input_header->source_port);
ntoh16 (input_header->dest_port);
ntoh32 (input_header->seq_num);
ntoh32 (input_header->ack_num);
ntoh16 (input_header->header_len__flags);
ntoh16 (input_header->window_size);
ntoh16 (input_header->checksum);
ntoh16 (input_header->urgent_pointer);
// anon_source_port->anonimyze(&input_header->source_port, &output_header->source_port, sizeof(uint16_t));
transform_field (anon_source_port,&input_header->source_port,&output_header->source_port, sizeof (uint16_t));
transform_field (anon_dest_port, &input_header->dest_port, &output_header->dest_port, sizeof (uint16_t));
transform_field (anon_seq_num, &input_header->seq_num, &output_header->seq_num, sizeof (uint32_t));
transform_field (anon_ack_num, &input_header->ack_num, &output_header->ack_num, sizeof (uint32_t));
uint16_t flags_original = get_flags (input_header);
uint16_t flags_transformed = 0;
transform_field (anon_flags, &flags_original, &flags_transformed, sizeof (uint16_t));
set_flags (flags_transformed, output_header);
transform_field (anon_window_size, &input_header->window_size, &output_header->window_size, sizeof (uint16_t));
transform_field (anon_urgent_pointer, &input_header->urgent_pointer, &output_header->urgent_pointer, sizeof (uint16_t));
size_t options_length = get_header_len (input_header) - tcp_header_length;
size_t new_options_length = transform_field (anon_options, source_buffer + tcp_header_length, destination_buffer + tcp_header_length, options_length);
set_header_len (tcp_header_length + new_options_length, output_header);
// transform payload packet
auto payload_transformation = Transformation::getPayloadTransformation();
size_t new_payload_length = payload_transformation->transform (source_buffer + get_header_len(input_header), destination_buffer + get_header_len(output_header), max_packet_length - get_header_len(input_header) );
hton16 (output_header->source_port);
hton16 (output_header->dest_port);
hton32 (output_header->seq_num);
hton32 (output_header->ack_num);
hton16 (output_header->header_len__flags);
hton16 (output_header->window_size);
hton16 (output_header->checksum);
hton16 (output_header->urgent_pointer);
return tcp_header_length + new_options_length + new_payload_length;
}
int TcpPacketTransformation::calculate_checksum ( uint8_t* source_address, uint8_t* destination_address, unsigned int address_length, uint16_t length, uint8_t* sink_next_header ) const noexcept
{
TCP_HEADER* tcp_header = (TCP_HEADER*) sink_next_header;
tcp_header->checksum = 1;
size_t header_length = sizeof (TCP_HEADER);
size_t payload_length = length - header_length;
// TRACE(header_length);
// TRACE(payload_length);
// TRACE(length);
hton16 (length);
tcp_header->checksum = 0;
uint16_t padded_protocol = htons (IPPROTO_TCP & 0x00ff);
Checksum checksum;
// source address
checksum.update (source_address, address_length);
// destination address
checksum.update (destination_address, address_length);
// zero, protocol and length
checksum.update (&length, 2);
checksum.update (&padded_protocol, 2);
// add udp header
checksum.update (tcp_header, header_length);
// add packet payload
checksum.update (sink_next_header + header_length, payload_length);
// complete
tcp_header->checksum = checksum.final();
// hton16 (tcp_header->checksum);
return 0;
}
// TCP Checksum Calculation
// pseudoheader
// +--------+--------+--------+--------+
// | Source Address |
// +--------+--------+--------+--------+
// | Destination Address |
// +--------+--------+--------+--------+
// | zero | PTCL | TCP Length |
// +--------+--------+--------+--------+
// tcp header
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Source Port | Destination Port |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Sequence Number |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Acknowledgment Number |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Data | |U|A|P|R|S|F| |
// | Offset| Reserved |R|C|S|S|Y|I| Window |
// | | |G|K|H|T|N|N| |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Checksum | Urgent Pointer |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Options | Padding |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | data |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
pktanon-master/libpktanon/transformations/Transformation.h 0000644 0000000 0000000 00000004252 12701423271 023272 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_TRANSFORMATION_H
#define PKTANON_TRANSFORMATION_H
#include
#include
#include "anonprimitives/AnonPrimitive.h"
#include "PHT.h"
namespace pktanon
{
class Transformation
{
public:
virtual ~Transformation();
static Transformation* getTransformationLinktype ( uint32_t linktype );
static const Transformation* const getTransformationEthertype ( uint16_t ethertype )
{
return ethetype_lookup_table.lookup ( ethertype, payloadTransformation );
};
static const Transformation* const getTransformationProtocol ( uint8_t protocol )
{
return protocol_lookup_table.lookup ( protocol, payloadTransformation );
};
static Transformation* getPayloadTransformation() {return payloadTransformation;};
static bool hasPseudoHeader ( uint8_t protocol )
{
return checksums_lookup_table.contains ( protocol );
};
private:
friend class TransformationsConfigurator;
static std::unordered_map linktype_lookup_table;
static PHT ethetype_lookup_table;
static PHT protocol_lookup_table;
static PHT checksums_lookup_table;
static Transformation* payloadTransformation;
public:
virtual int transform ( const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length ) const noexcept = 0;
static size_t transform_field ( AnonPrimitive const * anon, const void* input_buffer, void* output_buffer, size_t field_orig_length )
{
if ( anon == nullptr ) return 0;
return anon->anonimyze ( input_buffer, output_buffer, field_orig_length );
};
static void ntoh16 ( uint16_t& val ) { val = ntohs ( val );}
static void ntoh32 ( uint32_t& val ) { val = ntohl ( val );}
static void hton16 ( uint16_t& val ) { val = htons ( val );}
static void hton32 ( uint32_t& val ) { val = htonl ( val );}
};
}
#endif // PKTANON_TRANSFORMATION_H
pktanon-master/libpktanon/transformations/ICMPv6PacketTransformation.h 0000644 0000000 0000000 00000004230 12701423271 025343 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_ICMPV6PACKETTRANSFORMATION_H
#define PKTANON_ICMPV6PACKETTRANSFORMATION_H
# include "Transformation.h"
#include "PseudoheaderAwareTransformation.h"
namespace pktanon
{
# pragma pack (1)
struct ICMPv6_HEADER
{
uint8_t type;
uint8_t code;
uint16_t checksum;
uint32_t misc;
} ;
# pragma pack ()
# pragma pack (1)
struct ICMPv6_NSM_HEADER //NSM = neighbor solicitation message
{
uint32_t reserved;
in6_addr target_address;
} ;
# pragma pack ()
# pragma pack (1)
struct ICMPv6_NAM_HEADER //NAM = neighbor advertisement message
{
uint32_t rso__reserved;
in6_addr target_address;
} ;
# pragma pack ()
enum ICMPv6_Types{
NDP_NSM = 135, // Neighbor Solicitation (NDP)
NDP_NAM = 136, // Neighbor Advertisement (NDP)
};
class ICMPv6PacketTransformation : public PseudoheaderAwareTransformation
{
public:
virtual ~ICMPv6PacketTransformation();
ICMPv6PacketTransformation (
AnonPrimitive* anon_type,
AnonPrimitive* anon_code,
AnonPrimitive* anon_misc,
AnonPrimitive* anon_target_address
);
virtual int transform (const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const noexcept;
virtual int calculate_checksum (uint8_t* source_address, uint8_t* destination_address, unsigned address_length, uint16_t ip_length, uint8_t* sink_next_header) const noexcept;
private:
int nsm_transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const;
int nam_transform(const uint8_t* source_buffer, uint8_t* destination_buffer, unsigned max_packet_length) const;
AnonPrimitive* anon_type;
AnonPrimitive* anon_code;
AnonPrimitive* anon_misc;
AnonPrimitive* anon_target_address;
};
}
#endif // PKTANON_ICMPV6PACKETTRANSFORMATION_H
pktanon-master/libpktanon/transformations/DefaultTransformationsConfigurator.cpp 0000644 0000000 0000000 00000037565 12701423271 027715 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "DefaultTransformationsConfigurator.h"
//---------------------------------------------------------------------------------
#include "log.h"
#include "AnonFactory.h"
#include "anonprimitives/AnonPrimitive.h"
#include "anonprimitives/AnonIdentity.h"
#include "transformations/TransformationsConfigurator.h"
#include "Transformation.h"
#include "ProtocolUtils.h"
#include "EthernetPacketTransformation.h"
#include "VlanTagTransformation.h"
#include "LinuxCookedCaptureTransformation.h"
#include "ArpPacketTransformation.h"
#include "IPv4PacketTransformation.h"
#include "IPv6PacketTransformation.h"
#include "UdpPacketTransformation.h"
#include "TcpPacketTransformation.h"
#include "IcmpPacketTransformation.h"
#include "ICMPv6PacketTransformation.h"
#include "PayloadTransformation.h"
using namespace pktanon;
void DefaultTransformationsConfigurator::configure_ethernet_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring ethernet packet:");
AnonPrimitive* anon_mac_source = TransformationsConfigurator::configure_packet_field ("mac-source", packet_config);
AnonPrimitive* anon_mac_destination = TransformationsConfigurator::configure_packet_field ("mac-dest", packet_config);
AnonPrimitive* anon_ethertype = TransformationsConfigurator::configure_packet_field ("ethertype", packet_config);
EthernetPacketTransformation::PAD pad_mode = EthernetPacketTransformation::PAD::KEEP_LEN;
const auto& params = config.get_global_parameters();
if (params.has_param ("pad-ethernet-packets"))
{
const string& pad_config = params.get_param ("pad-ethernet-packets");
if (pad_config.compare ("always") == 0)
pad_mode = EthernetPacketTransformation::PAD::ALWAYS;
else if (pad_config.compare ("keep-length") == 0)
pad_mode = EthernetPacketTransformation::PAD::KEEP_LEN;
else if (pad_config.compare ("never") == 0)
pad_mode = EthernetPacketTransformation::PAD::NEVER;
else
throw std::runtime_error ("wrong value for 'pad-ethernet-packets' parameter: use always/keep-length/never");
_plg_verbose ("\t\tpad-ethernet-packets = " << pad_config);
}
EthernetPacketTransformation* ether_tr =
new EthernetPacketTransformation (anon_mac_source, anon_mac_destination, anon_ethertype, pad_mode);
TransformationsConfigurator::instance().add_linktype (1, ether_tr);
}
void DefaultTransformationsConfigurator::configure_vlan_tag ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring vlan tag:");
AnonPrimitive* anon_priority = TransformationsConfigurator::configure_packet_field ("priority", packet_config);
AnonPrimitive* anon_cfi = TransformationsConfigurator::configure_packet_field ("cfi", packet_config);
AnonPrimitive* anon_vlan_id = TransformationsConfigurator::configure_packet_field ("id", packet_config);
AnonPrimitive* anon_type = TransformationsConfigurator::configure_packet_field ("ethertype", packet_config);
VlanTagTransformation* vlan_tr = new VlanTagTransformation (anon_priority, anon_cfi, anon_vlan_id, anon_type);
TransformationsConfigurator::instance().add_ethertype (EtherTypes::ETHERTYPE_VLAN, vlan_tr);
}
void DefaultTransformationsConfigurator::configure_linux_sll_packet( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring linux cooked capture packet:");
AnonPrimitive* anon_packet_type = TransformationsConfigurator::configure_packet_field ("packet-type", packet_config);
AnonPrimitive* anon_hardware_type = TransformationsConfigurator::configure_packet_field ("ll-address-type", packet_config);
AnonPrimitive* anon_link_layer_addr = TransformationsConfigurator::configure_packet_field ("ll-address", packet_config);
AnonPrimitive* anon_protocol_type = TransformationsConfigurator::configure_packet_field ("protocol", packet_config);
LinuxCookedCaptureTransformation* sll_tr =
new LinuxCookedCaptureTransformation (anon_packet_type, anon_hardware_type, anon_link_layer_addr, anon_protocol_type);
TransformationsConfigurator::instance().add_linktype (113, sll_tr);
}
void DefaultTransformationsConfigurator::configure_arp_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring arp packet:");
AnonPrimitive* anon_hardware_type = TransformationsConfigurator::configure_packet_field ("hardware-type", packet_config);
AnonPrimitive* anon_protocol_type = TransformationsConfigurator::configure_packet_field ("protocol-type", packet_config);
AnonPrimitive* anon_hardware_size = TransformationsConfigurator::configure_packet_field ("hardware-size", packet_config);
AnonPrimitive* anon_protocol_size = TransformationsConfigurator::configure_packet_field ("protocol-size", packet_config);
AnonPrimitive* anon_opcode = TransformationsConfigurator::configure_packet_field ("opcode", packet_config);
AnonPrimitive* anon_sender_mac = TransformationsConfigurator::configure_packet_field ("sender-mac", packet_config);
AnonPrimitive* anon_sender_ip = TransformationsConfigurator::configure_packet_field ("sender-ip", packet_config);
AnonPrimitive* anon_target_mac = TransformationsConfigurator::configure_packet_field ("target-mac", packet_config);
AnonPrimitive* anon_target_ip = TransformationsConfigurator::configure_packet_field ("target-ip", packet_config);
ArpPacketTransformation* arp_tr = new ArpPacketTransformation (
anon_hardware_type, anon_protocol_type,
anon_hardware_size, anon_protocol_size,
anon_opcode,
anon_sender_mac, anon_sender_ip,
anon_target_mac, anon_target_ip
);
TransformationsConfigurator::instance().add_ethertype (EtherTypes::ETHERTYPE_ARP, arp_tr);
}
void DefaultTransformationsConfigurator::configure_ipv4_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring ip(v4) packet:");
AnonPrimitive* anon_tos = TransformationsConfigurator::configure_packet_field ("tos", packet_config);
AnonPrimitive* anon_identification = TransformationsConfigurator::configure_packet_field ("identification", packet_config);
AnonPrimitive* anon_flags = TransformationsConfigurator::configure_packet_field ("flags", packet_config);
AnonPrimitive* anon_fragment_offset = TransformationsConfigurator::configure_packet_field ("fragment", packet_config);
AnonPrimitive* anon_ttl = TransformationsConfigurator::configure_packet_field ("ttl", packet_config);
AnonPrimitive* anon_protocol = TransformationsConfigurator::configure_packet_field ("protocol", packet_config);
AnonPrimitive* anon_source_ip = TransformationsConfigurator::configure_packet_field ("src-ip", packet_config);
AnonPrimitive* anon_destination_ip = TransformationsConfigurator::configure_packet_field ("dest-ip", packet_config);
AnonPrimitive* anon_options = TransformationsConfigurator::configure_packet_field ("options", packet_config);
bool recalculate_ipv4_header_checksum = true;
bool recalculate_payload_checksums = true;
const auto& params = config.get_global_parameters();
if (params.has_param ("recalculate-ipv4-header-checksum"))
{
const string& pad_config = params.get_param ("recalculate-ipv4-header-checksum");
if (pad_config.compare ("yes") == 0)
recalculate_ipv4_header_checksum = true;
else if (pad_config.compare ("no") == 0)
recalculate_ipv4_header_checksum = false;
else
throw std::runtime_error ("wrong value for 'recalculate-ipv4-header-checksum' parameter: use yes/no");
_plg_verbose ("\t\trecalculate-ipv4-header-checksum = " << recalculate_ipv4_header_checksum);
}
if (params.has_param ("recalculate-payload-checksums"))
{
const string& pad_config = params.get_param ("recalculate-payload-checksums");
if (pad_config.compare ("yes") == 0)
recalculate_payload_checksums = true;
else if (pad_config.compare ("no") == 0)
recalculate_payload_checksums = false;
else
throw std::runtime_error ("wrong value for 'recalculate-payload-checksums' parameter: use yes/no");
_plg_verbose ("\t\trecalculate-payload-checksums = " << recalculate_payload_checksums);
}
IPv4PacketTransformation* ip4_tr = new IPv4PacketTransformation (
anon_tos, anon_identification, anon_flags, anon_fragment_offset,
anon_ttl, anon_protocol, anon_source_ip, anon_destination_ip,
anon_options, recalculate_ipv4_header_checksum, recalculate_payload_checksums
);
TransformationsConfigurator::instance().add_ethertype (EtherTypes::ETHERTYPE_IP, ip4_tr);
TransformationsConfigurator::instance().add_protocol (IPPROTO_IPIP, ip4_tr);
}
void DefaultTransformationsConfigurator::configure_ipv6_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring ipv6 packet:");
AnonPrimitive* anon_traffic_class = TransformationsConfigurator::configure_packet_field ("traffic-class", packet_config);;
AnonPrimitive* anon_flow_label = TransformationsConfigurator::configure_packet_field ("flow-label", packet_config);;
AnonPrimitive* anon_next_header = TransformationsConfigurator::configure_packet_field ("next-header", packet_config);;
AnonPrimitive* anon_hop_limit = TransformationsConfigurator::configure_packet_field ("hop-limit", packet_config);;
AnonPrimitive* anon_source_addr = TransformationsConfigurator::configure_packet_field ("src-ip", packet_config);;
AnonPrimitive* anon_destination_addr = TransformationsConfigurator::configure_packet_field ("dest-ip", packet_config);;
if (anon_next_header == nullptr)
_plg_warn ("next-header field will be absent in the trace");
bool recalculate_payload_checksums = true;
const auto& params = config.get_global_parameters();
if (params.has_param ("recalculate-payload-checksums"))
{
const string& pad_config = params.get_param ("recalculate-payload-checksums");
if (pad_config.compare ("yes") == 0)
recalculate_payload_checksums = true;
else if (pad_config.compare ("no") == 0)
recalculate_payload_checksums = false;
else
throw std::runtime_error ("wrong value for 'recalculate-payload-checksums' parameter: use yes/no");
_plg_verbose ("\t\trecalculate-payload-checksums = " << recalculate_payload_checksums);
}
IPv6PacketTransformation* ipv6_tr = new IPv6PacketTransformation (
anon_traffic_class, anon_flow_label,
anon_next_header, anon_hop_limit,
anon_source_addr, anon_destination_addr,
recalculate_payload_checksums
);
TransformationsConfigurator::instance().add_ethertype (EtherTypes::ETHERTYPE_IPV6, ipv6_tr);
TransformationsConfigurator::instance().add_protocol (IPPROTO_IPV6, ipv6_tr);
}
void DefaultTransformationsConfigurator::configure_icmp_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring icmp(v4) packet:");
AnonPrimitive* anon_type = TransformationsConfigurator::configure_packet_field ("type", packet_config);
AnonPrimitive* anon_code = TransformationsConfigurator::configure_packet_field ("code", packet_config);
AnonPrimitive* anon_misc = TransformationsConfigurator::configure_packet_field ("rest", packet_config);
IcmpPacketTransformation* icmp_tr = new IcmpPacketTransformation (
anon_type, anon_code, anon_misc
);
TransformationsConfigurator::instance().add_protocol (IPPROTO_ICMP, icmp_tr);
}
void DefaultTransformationsConfigurator::configure_icmpv6_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring icmp(v6) packet:");
AnonPrimitive* anon_type = TransformationsConfigurator::configure_packet_field ("type", packet_config);
AnonPrimitive* anon_code = TransformationsConfigurator::configure_packet_field ("code", packet_config);
AnonPrimitive* anon_misc = TransformationsConfigurator::configure_packet_field ("rest", packet_config);
AnonPrimitive* anon_target_address = TransformationsConfigurator::configure_packet_field ("target-address", packet_config);
ICMPv6PacketTransformation* icmp_tr = new ICMPv6PacketTransformation (
anon_type, anon_code, anon_misc, anon_target_address
);
TransformationsConfigurator::instance().add_protocol (IPPROTO_ICMPV6, icmp_tr);
}
void DefaultTransformationsConfigurator::configure_tcp_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring tcp packet:");
AnonPrimitive* anon_source_port = TransformationsConfigurator::configure_packet_field ("source-port", packet_config);;
AnonPrimitive* anon_dest_port = TransformationsConfigurator::configure_packet_field ("dest-port", packet_config);;
AnonPrimitive* anon_seq_num = TransformationsConfigurator::configure_packet_field ("seq", packet_config);;
AnonPrimitive* anon_ack_num = TransformationsConfigurator::configure_packet_field ("ack", packet_config);;
AnonPrimitive* anon_flags = TransformationsConfigurator::configure_packet_field ("flags", packet_config);;
AnonPrimitive* anon_window_size = TransformationsConfigurator::configure_packet_field ("window-size", packet_config);;
AnonPrimitive* anon_urgent_pointer = TransformationsConfigurator::configure_packet_field ("urgent-pointer", packet_config);;
AnonPrimitive* anon_options = TransformationsConfigurator::configure_packet_field ("options", packet_config);;
TcpPacketTransformation* tcp_tr = new TcpPacketTransformation (
anon_source_port, anon_dest_port,
anon_seq_num, anon_ack_num,
anon_flags, anon_window_size,
anon_urgent_pointer, anon_options
);
TransformationsConfigurator::instance().add_protocol (IPPROTO_TCP, tcp_tr);
}
void DefaultTransformationsConfigurator::configure_udp_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring udp packet:");
AnonPrimitive* anon_source_port = TransformationsConfigurator::configure_packet_field ("source-port", packet_config);
AnonPrimitive* anon_destination_port = TransformationsConfigurator::configure_packet_field ("dest-port", packet_config);
UdpPacketTransformation* udp_tr = new UdpPacketTransformation (anon_source_port, anon_destination_port);
TransformationsConfigurator::instance().add_protocol (IPPROTO_UDP, udp_tr);
}
void DefaultTransformationsConfigurator::configure_payload_packet ( const PktAnonConfig::PacketConfig& packet_config, const PktAnonConfig& config )
{
_plg_verbose ("\tconfiguring payload packet:");
AnonPrimitive* anon_payload = TransformationsConfigurator::configure_packet_field ("payload", packet_config);
PayloadTransformation* payload_tr = new PayloadTransformation (anon_payload);
TransformationsConfigurator::instance().add_payload_transformation (payload_tr);
}
REGISTER_PACKET (ethernet, DefaultTransformationsConfigurator::configure_ethernet_packet);
REGISTER_PACKET (vlan, DefaultTransformationsConfigurator::configure_vlan_tag);
REGISTER_PACKET (linux_sll, DefaultTransformationsConfigurator::configure_linux_sll_packet);
REGISTER_PACKET (arp, DefaultTransformationsConfigurator::configure_arp_packet);
REGISTER_PACKET (ip, DefaultTransformationsConfigurator::configure_ipv4_packet);
REGISTER_PACKET (ipv4, DefaultTransformationsConfigurator::configure_ipv4_packet);
REGISTER_PACKET (ipv6, DefaultTransformationsConfigurator::configure_ipv6_packet);
REGISTER_PACKET (icmp, DefaultTransformationsConfigurator::configure_icmp_packet);
REGISTER_PACKET (icmpv6, DefaultTransformationsConfigurator::configure_icmpv6_packet);
REGISTER_PACKET (tcp, DefaultTransformationsConfigurator::configure_tcp_packet);
REGISTER_PACKET (udp, DefaultTransformationsConfigurator::configure_udp_packet);
REGISTER_PACKET (payload, DefaultTransformationsConfigurator::configure_payload_packet);
pktanon-master/libpktanon/anonprimitives/ 0000755 0000000 0000000 00000000000 12701423271 017726 5 ustar root root pktanon-master/libpktanon/anonprimitives/AnonConstOverwriteRange.h 0000644 0000000 0000000 00000001726 12701423271 024673 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANONCONSTOVERWRITERANGE_H
#define PKTANON__ANONCONSTOVERWRITERANGE_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonConstOverwriteRange : public AnonPrimitive
{
public:
static AnonConstOverwriteRange* construct ( const pktanon::Params& params );
AnonConstOverwriteRange ( int range_begin, int range_length, uint8_t value );
virtual ~AnonConstOverwriteRange();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
private:
int range_begin;
int range_length;
uint8_t value;
};
}
#endif // PKTANON_ANONCONSTOVERWRITERANGE_H
pktanon-master/libpktanon/anonprimitives/AnonCryptoPan.cpp 0000644 0000000 0000000 00000002645 12701423271 023174 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonCryptoPan.h"
#include
#include
#include
namespace pktanon
{
AnonCryptoPan* AnonCryptoPan::construct(pktanon::Params& params)
{
if (!params.has_param("key"))
throw std::runtime_error("incomplete configuration for AnonCryptoPan: missing key attribute");
return new AnonCryptoPan(params.get_param("key"));
}
AnonCryptoPan::AnonCryptoPan(string _key) :
key(_key), cryptopan((const UINT8*) key.c_str())
{
}
AnonCryptoPan::~AnonCryptoPan()
{
}
AnonPrimitive::ANON_RESULT AnonCryptoPan::anonymize_chain(void* buf, unsigned int len) const
{
assert(len == sizeof (UINT32));
UINT32 orig = 0;
memcpy(&orig, buf, sizeof(UINT32));
orig = const_cast(this)->cryptopan.anonymize(orig);
memcpy(buf, &orig, sizeof(UINT32));
return ANON_RESULT(len);
}
AnonPrimitive::ANON_RESULT AnonCryptoPan::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
assert(len == sizeof (UINT32));
UINT32 orig = * (UINT32*) src_buff;
orig = const_cast(this)->cryptopan.anonymize(orig);
* (UINT32*) dst_buff = orig;
return ANON_RESULT(len);
}
}
pktanon-master/libpktanon/anonprimitives/AnonHashSha256_Nettle.cpp 0000644 0000000 0000000 00000004157 12701423271 024344 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "anonprimitives/AnonHashSha256.h"
#include
#include
#include
namespace pktanon
{
AnonHashSha256::AnonHashSha256 ( bool truncate ) :
truncate ( truncate )
{ }
AnonPrimitive::ANON_RESULT AnonHashSha256::anonymize_chain ( void* buf, unsigned int len ) const
{
struct sha256_ctx ctx;
sha256_init ( &ctx );
sha256_update ( &ctx, len, ( unsigned char* ) buf );
sha256_digest ( &ctx, std::min ( ( int ) len, SHA256_DIGEST_SIZE ), ( unsigned char* ) buf );
if ( SHA256_DIGEST_SIZE >= len || truncate )
{
return ANON_RESULT ( std::min ( ( int ) len, SHA256_DIGEST_SIZE ) );
}
int pos = SHA256_DIGEST_SIZE;
int remaining = len - SHA256_DIGEST_SIZE;
while ( remaining > 0 )
{
memcpy ( ( unsigned char* ) buf + pos, buf, std::min ( remaining, SHA256_DIGEST_SIZE ) );
pos+= SHA256_DIGEST_SIZE;
remaining-=SHA256_DIGEST_SIZE;
}
return ANON_RESULT ( len );
}
AnonPrimitive::ANON_RESULT AnonHashSha256::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
struct sha256_ctx ctx;
nettle_sha256_init ( &ctx );
nettle_sha256_update ( &ctx, len, ( unsigned char* ) src_buff );
nettle_sha256_digest ( &ctx, std::min ( ( int ) len, SHA256_DIGEST_SIZE ), ( unsigned char* ) dst_buff );
if ( SHA256_DIGEST_SIZE >= len || truncate )
{
return ANON_RESULT ( std::min ( ( int ) len, SHA256_DIGEST_SIZE ) );
}
int pos = SHA256_DIGEST_SIZE;
int remaining = len - SHA256_DIGEST_SIZE;
while ( remaining > 0 )
{
memcpy ( ( unsigned char* ) dst_buff + pos, dst_buff, std::min ( remaining, SHA256_DIGEST_SIZE ) );
pos+= SHA256_DIGEST_SIZE;
remaining-=SHA256_DIGEST_SIZE;
}
return ANON_RESULT ( len );
}
REGISTER_ANON ( AnonHashSha256 );
}
pktanon-master/libpktanon/anonprimitives/AnonBroadcastHandler.h 0000644 0000000 0000000 00000001632 12701423271 024115 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_BROADCAST_HANDLER_H
#define PKTANON__ANON_BROADCAST_HANDLER_H
#include "AnonPrimitive.h"
namespace pktanon
{
/**
* prevents anonymization of strings consisting of 0xFF chars
*
* can be used to prevent anonymization of broadcast IP and MAC addresses
*/
class AnonBroadcastHandler: public AnonPrimitive
{
public:
AnonBroadcastHandler();
virtual ~AnonBroadcastHandler();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const ;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
};
}
#endif // __ANON_BROADCAST_HANDLER_H
pktanon-master/libpktanon/anonprimitives/AnonHashSha1.h 0000644 0000000 0000000 00000001377 12701423271 022323 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_HASH_SHA1_H
#define PKTANON__ANON_HASH_SHA1_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonHashSha1: public AnonPrimitive
{
public:
AnonHashSha1 ( bool truncate = false );
virtual ~AnonHashSha1();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
virtual ANON_RESULT anonymize_internal ( const void* const src_buff, void* dst_buff, unsigned int len ) const;
private:
bool truncate;
};
}
#endif // __ANON_HASH_SHA1_H
pktanon-master/libpktanon/anonprimitives/AnonContinuousChar.cpp 0000644 0000000 0000000 00000001220 12701423271 024205 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonContinuousChar.h"
#include
#include "AnonFactory.h"
namespace pktanon
{
AnonContinuousChar::AnonContinuousChar() : current(0)
{
}
AnonContinuousChar::~AnonContinuousChar()
{
}
AnonPrimitive::ANON_RESULT AnonContinuousChar::anonymize_chain(void* buf, unsigned int len) const
{
memset(buf, current++, len);
return 0;
}
REGISTER_ANON(AnonContinuousChar);
}
pktanon-master/libpktanon/anonprimitives/AnonConstOverwriteRange.cpp 0000644 0000000 0000000 00000004212 12701423271 025217 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonConstOverwriteRange.h"
#include "AnonFactory.h"
#include
#include
#include
using namespace pktanon;
AnonConstOverwriteRange* AnonConstOverwriteRange::construct(const pktanon::Params& params)
{
if (!params.has_param("range-begin"))
throw std::runtime_error("incomplete configuration for AnonConstOverwriteRange - missing attribute: range-begin");
if (!params.has_param("range-length"))
throw std::runtime_error("incomplete configuration for AnonConstOverwriteRange - missing attribute: range-length");
if (!params.has_param("value"))
throw std::runtime_error("incomplete configuration for AnonConstOverwriteRange - missing attribute: value");
int range_begin = std::stoi(params.get_param("range-begin"));
int range_length = std::stoi(params.get_param("range-length"));
uint8_t value = std::stoul(params.get_param("value"), nullptr, 16);
// TRACE(range_begin);
// TRACE(range_length);
// TRACE(value);
return new AnonConstOverwriteRange(range_begin, range_length, value);
}
AnonConstOverwriteRange::AnonConstOverwriteRange(int range_begin, int range_length, uint8_t value):
range_begin(range_begin), range_length(range_length), value(value)
{}
AnonConstOverwriteRange::~AnonConstOverwriteRange() = default;
AnonPrimitive::ANON_RESULT AnonConstOverwriteRange::anonymize_chain(void* buf, unsigned int len) const
{
memset(((uint8_t*)buf)+range_begin, value, std::min(range_length, (int) len-range_begin));
return ANON_RESULT(len);
}
AnonPrimitive::ANON_RESULT AnonConstOverwriteRange::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
memcpy(dst_buff, src_buff, len);
memset(((uint8_t*)dst_buff)+range_begin, value, std::min(range_length, (int) len-range_begin));
return ANON_RESULT(len);
}
REGISTER_ANON_PARAM(AnonConstOverwriteRange, AnonConstOverwriteRange::construct);
pktanon-master/libpktanon/anonprimitives/AnonBytewiseHashSha1.cpp 0000644 0000000 0000000 00000001447 12701423271 024370 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonBytewiseHashSha1.h"
#include "AnonHashSha1.h"
#include "AnonFactory.h"
namespace pktanon
{
AnonBytewiseHashSha1::AnonBytewiseHashSha1()
{
fillTable();
}
AnonBytewiseHashSha1::~AnonBytewiseHashSha1()
{
}
void AnonBytewiseHashSha1::fillTable()
{
unsigned char data;
AnonHashSha1 hashobj;
for (unsigned short i = 0; i < 256; i++)
{
data = (unsigned char) i;
hashobj.anonimyze (&data, 1);
anonbytes[i] = data;
} // for (unsigned short i = 0; i<256; i++)
}
REGISTER_ANON (AnonBytewiseHashSha1);
}
pktanon-master/libpktanon/anonprimitives/AnonBytewiseHashHmacSha1.cpp 0000644 0000000 0000000 00000002452 12701423271 025156 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonBytewiseHashHmacSha1.h"
#include "AnonHashHmacSha1.h"
#include
#include "AnonFactory.h"
namespace pktanon
{
AnonBytewiseHashHmacSha1* AnonBytewiseHashHmacSha1::construct (std::unordered_map attrmap)
{
auto it = attrmap.find ("key");
string key;
if (it == attrmap.end())
{
throw std::runtime_error ("incomplete configuration for AnonBytewiseHashHmacSha1: missing key attribute");
}
key = it->second;
return new AnonBytewiseHashHmacSha1 (key);
}
AnonBytewiseHashHmacSha1::AnonBytewiseHashHmacSha1 (string key)
{
fillTable (key);
}
AnonBytewiseHashHmacSha1::~AnonBytewiseHashHmacSha1()
{
}
void AnonBytewiseHashHmacSha1::fillTable (string& hmackey)
{
unsigned char data;
AnonHashHmacSha1 hashobj (hmackey);
for (unsigned short i = 0; i < 256; i++)
{
data = (unsigned char) i;
hashobj.anonimyze (&data, 1);
anonbytes[i] = data;
} // for (unsigned short i = 0; i<256; i++)
}
REGISTER_ANON_PARAM (AnonBytewiseHashHmacSha1, AnonBytewiseHashHmacSha1::construct);
}
pktanon-master/libpktanon/anonprimitives/AnonBytewiseHashHmacSha1.h 0000644 0000000 0000000 00000001357 12701423271 024626 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef __ANON_BYTEWISE_HASH_HMAC_SHA1_H
#define __ANON_BYTEWISE_HASH_HMAC_SHA1_H
#include "AnonBytewise.h"
# include "unordered_map"
namespace pktanon
{
class AnonBytewiseHashHmacSha1: public AnonBytewise
{
public:
static AnonBytewiseHashHmacSha1* construct(std::unordered_map attrmap);
AnonBytewiseHashHmacSha1(string key);
virtual ~AnonBytewiseHashHmacSha1();
private:
void fillTable(string& hmackey);
};
}
#endif // __ANON_BYTEWISE_HASH_HMAC_SHA1_H
pktanon-master/libpktanon/anonprimitives/AnonContinuousChar.h 0000644 0000000 0000000 00000001243 12701423271 023657 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_CONTINUOUS_CHAR_H
#define PKTANON__ANON_CONTINUOUS_CHAR_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonContinuousChar: public AnonPrimitive
{
public:
AnonContinuousChar();
virtual ~AnonContinuousChar();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
private:
unsigned char current;
};
}
#endif // __ANON_CONTINUOUS_CHAR_H
pktanon-master/libpktanon/anonprimitives/AnonBytewise.h 0000644 0000000 0000000 00000001164 12701423271 022510 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_BYTEWISE_H
#define PKTANON__ANON_BYTEWISE_H
#include "anonprimitives/AnonPrimitive.h"
namespace pktanon
{
class AnonBytewise: public AnonPrimitive
{
public:
AnonBytewise();
virtual ~AnonBytewise();
protected:
ANON_RESULT anonymize (void* buf, unsigned int len);
unsigned char anonbytes[256];
};
}
#endif // __ANON_BYTEWISE_H
pktanon-master/libpktanon/anonprimitives/AnonKnownProtocolHandler.cpp 0000644 0000000 0000000 00000002750 12701423271 025366 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonKnownProtocolHandler.h"
#include "AnonFactory.h"
#include "transformations/Transformation.h"
using namespace pktanon;
AnonKnownProtocolHandler::~AnonKnownProtocolHandler() = default;
AnonKnownProtocolHandler::AnonKnownProtocolHandler()
{}
AnonPrimitive::ANON_RESULT AnonKnownProtocolHandler::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
memcpy(dst_buff, src_buff, len);
return anonymize_chain(dst_buff, len);
}
AnonPrimitive::ANON_RESULT AnonKnownProtocolHandler::anonymize_chain ( void* buf, unsigned int len ) const
{
uint8_t protocol = ((uint8_t*)buf)[0];
if(Transformation::getTransformationProtocol(protocol) == Transformation::getPayloadTransformation())
{
return ANON_RESULT(len, false);
}
else
{
return ANON_RESULT(len);
}
}
// AnonPrimitive::ANON_RESULT AnonKnownProtocolHandler::anonymize ( void* buf, unsigned int len ) const
// {
// uint8_t protocol = ((uint8_t*)buf)[0];
// if(Transformation::getTransformationProtocol(protocol) == Transformation::getPayloadTransformation())
// {
// return ANON_RESULT(len, false);
// }
// else
// {
// return ANON_RESULT(len);
// }
// }
REGISTER_ANON(AnonKnownProtocolHandler);
pktanon-master/libpktanon/anonprimitives/AnonRandomize.cpp 0000644 0000000 0000000 00000001677 12701423271 023211 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonRandomize.h"
#include
#include
namespace pktanon
{
AnonRandomize::~AnonRandomize() = default;
AnonRandomize::AnonRandomize() { }
AnonPrimitive::ANON_RESULT AnonRandomize::anonymize_chain(void* buf, unsigned int len) const
{
RandomNumberGenerator::generate_random_bytes (reinterpret_cast(buf), len);
return ANON_RESULT (len);
}
AnonPrimitive::ANON_RESULT AnonRandomize::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
RandomNumberGenerator::generate_random_bytes (reinterpret_cast(dst_buff), len);
return ANON_RESULT (len);
}
REGISTER_ANON (AnonRandomize);
}
pktanon-master/libpktanon/anonprimitives/AnonKnownEthertypeHandler.h 0000644 0000000 0000000 00000001427 12701423271 025203 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_ANONKNOWNETHERTYPEHANDLER_H
#define PKTANON_ANONKNOWNETHERTYPEHANDLER_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonKnownEthertypeHandler : public AnonPrimitive
{
public:
AnonKnownEthertypeHandler();
virtual ~AnonKnownEthertypeHandler();
protected:
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
};
}
#endif // PKTANON_ANONKNOWNETHERTYPEHANDLER_H
pktanon-master/libpktanon/anonprimitives/AnonKnownEthertypeHandler.cpp 0000644 0000000 0000000 00000002203 12701423271 025527 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonKnownEthertypeHandler.h"
#include "AnonFactory.h"
#include "transformations/Transformation.h"
namespace pktanon {
AnonKnownEthertypeHandler::~AnonKnownEthertypeHandler() = default;
AnonKnownEthertypeHandler::AnonKnownEthertypeHandler()
{}
AnonPrimitive::ANON_RESULT AnonKnownEthertypeHandler::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
memcpy(dst_buff, src_buff, len);
return anonymize_chain(dst_buff, len);
}
AnonPrimitive::ANON_RESULT AnonKnownEthertypeHandler::anonymize_chain ( void* buf, unsigned int len ) const
{
uint16_t* ethertype = ( uint16_t* ) buf;
if ( Transformation::getTransformationEthertype ( *ethertype ) == Transformation::getPayloadTransformation() )
{
return ANON_RESULT ( len, false );
}
else
{
return ANON_RESULT ( len );
}
}
REGISTER_ANON(AnonKnownEthertypeHandler)
} pktanon-master/libpktanon/anonprimitives/AnonWhitenoise.h 0000644 0000000 0000000 00000001515 12701423271 023033 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef __ANON_WHITENOISE_H
#define __ANON_WHITENOISE_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonWhitenoise: public AnonPrimitive
{
public:
static AnonWhitenoise* construct ( const pktanon::Params& params );
AnonWhitenoise ( unsigned char strengthval );
virtual ~AnonWhitenoise();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
private:
unsigned char strength;
};
}
#endif // __ANON_WHITENOISE_H
pktanon-master/libpktanon/anonprimitives/AnonBytewiseHashSha1.h 0000644 0000000 0000000 00000001123 12701423271 024024 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_BYTEWISE_HASH_SHA1_H
# define PKTANON__ANON_BYTEWISE_HASH_SHA1_H
#include "AnonBytewise.h"
namespace pktanon
{
class AnonBytewiseHashSha1: public AnonBytewise
{
public:
AnonBytewiseHashSha1();
virtual ~AnonBytewiseHashSha1();
private:
void fillTable();
};
}
#endif // __ANON_BYTEWISE_HASH_SHA1_H
pktanon-master/libpktanon/anonprimitives/AnonConstOverwrite.cpp 0000644 0000000 0000000 00000002431 12701423271 024243 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonConstOverwrite.h"
#include "AnonFactory.h"
#include
#include
namespace pktanon
{
AnonConstOverwrite* AnonConstOverwrite::construct(const Params& params)
{
if (!params.has_param("value"))
throw std::runtime_error("incomplete configuration for AnonConstOverwrite: missing attribute 'value'");
unsigned char byte = strtoul(params.get_param("value").c_str(), nullptr, 16);
return new AnonConstOverwrite(byte);
}
AnonConstOverwrite::AnonConstOverwrite(unsigned char byte) :
byteval(byte)
{
}
AnonConstOverwrite::~AnonConstOverwrite()
{
}
AnonPrimitive::ANON_RESULT AnonConstOverwrite::anonymize_chain(void* buf, unsigned int len) const
{
memset(buf, byteval, len);
return ANON_RESULT(len);
}
AnonPrimitive::ANON_RESULT AnonConstOverwrite::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
// HB();
memset(dst_buff, byteval, len);
return ANON_RESULT(len);
}
REGISTER_ANON_PARAM(AnonConstOverwrite, AnonConstOverwrite::construct);
}
pktanon-master/libpktanon/anonprimitives/AnonShuffle.cpp 0000644 0000000 0000000 00000002021 12701423271 022635 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonShuffle.h"
#include
#include
#include "AnonFactory.h"
namespace pktanon
{
AnonShuffle::~AnonShuffle() = default;
AnonShuffle::AnonShuffle() { }
AnonPrimitive::ANON_RESULT AnonShuffle::anonymize_chain ( void* buf, unsigned int len ) const
{
unsigned char* buf1 = reinterpret_cast ( buf );
std::random_shuffle ( buf1, buf1+len );
return ANON_RESULT ( len );
}
AnonPrimitive::ANON_RESULT AnonShuffle::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
memcpy ( dst_buff, src_buff, len );
unsigned char* buff = reinterpret_cast ( dst_buff );
std::random_shuffle ( buff, buff+len );
return ANON_RESULT ( len );
}
REGISTER_ANON ( AnonShuffle );
}
pktanon-master/libpktanon/anonprimitives/AnonHashSha1_Nettle.cpp 0000644 0000000 0000000 00000003705 12701423271 024166 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonHashSha1.h"
#include "AnonFactory.h"
#include
#include
namespace pktanon
{
AnonHashSha1::AnonHashSha1(bool truncate)
{
}
AnonHashSha1::~AnonHashSha1()
{
}
AnonPrimitive::ANON_RESULT AnonHashSha1::anonymize_chain (void* buf, unsigned int len) const
{
thread_local static struct sha1_ctx ctx;
sha1_init (&ctx);
sha1_update (&ctx, len, (unsigned char*) buf);
sha1_digest (&ctx, std::min ( (int) len, SHA1_DIGEST_SIZE), (unsigned char*) buf);
if (SHA1_DIGEST_SIZE >= len || truncate)
{
return ANON_RESULT (std::min ( (int) len, SHA1_DIGEST_SIZE));
}
int pos = SHA1_DIGEST_SIZE;
int remaining = len - SHA1_DIGEST_SIZE;
while (remaining > 0)
{
memcpy ( (unsigned char*) buf + pos, buf, std::min (remaining, SHA1_DIGEST_SIZE));
pos += SHA1_DIGEST_SIZE;
remaining -= SHA1_DIGEST_SIZE;
}
return ANON_RESULT (len);
}
AnonPrimitive::ANON_RESULT AnonHashSha1::anonymize_internal ( const void* const src_buff, void* dst_buff, unsigned int len ) const
{
thread_local static struct sha1_ctx ctx;
nettle_sha1_init (&ctx);
nettle_sha1_update (&ctx, len, (unsigned char*) src_buff);
nettle_sha1_digest (&ctx, std::min ( (int) len, SHA1_DIGEST_SIZE), (unsigned char*) dst_buff);
if (SHA1_DIGEST_SIZE >= len || truncate)
{
return ANON_RESULT (std::min ( (int) len, SHA1_DIGEST_SIZE));
}
int pos = SHA1_DIGEST_SIZE;
int remaining = len - SHA1_DIGEST_SIZE;
while (remaining > 0)
{
memcpy ( (unsigned char*) dst_buff + pos, dst_buff, std::min (remaining, SHA1_DIGEST_SIZE));
pos += SHA1_DIGEST_SIZE;
remaining -= SHA1_DIGEST_SIZE;
}
return ANON_RESULT (len);
}
REGISTER_ANON (AnonHashSha1)
}
pktanon-master/libpktanon/anonprimitives/AnonIdentity.h 0000644 0000000 0000000 00000001321 12701423271 022501 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_IDENTITY_H
#define PKTANON__ANON_IDENTITY_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonIdentity: public AnonPrimitive
{
public:
AnonIdentity();
virtual ~AnonIdentity();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const ;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
};
}
#endif // PKTANON__ANON_IDENTITY_H
pktanon-master/libpktanon/anonprimitives/AnonBroadcastHandler.cpp 0000644 0000000 0000000 00000002445 12701423271 024453 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonBroadcastHandler.h"
#include "AnonFactory.h"
#include
#include
namespace pktanon
{
AnonBroadcastHandler::AnonBroadcastHandler() {}
AnonBroadcastHandler::~AnonBroadcastHandler() = default;
AnonPrimitive::ANON_RESULT AnonBroadcastHandler::anonymize_chain (void* buf, unsigned int len) const
{
//TODO try with std::find_if_not ...
unsigned char* buf1 = reinterpret_cast (buf);
bool continue_anon = std::any_of (buf1, buf1 + len, [](uint8_t j) {
return j != 0xFF;
});
return ANON_RESULT(len, continue_anon);
}
AnonPrimitive::ANON_RESULT AnonBroadcastHandler::anonymize_internal ( const void* const src_buff, void* dst_buff, unsigned int len ) const
{
const unsigned char* buf1 = reinterpret_cast (src_buff);
bool continue_anon = std::any_of (buf1, buf1 + len, [](uint8_t j) {
return j != 0xFF;
});
memcpy(dst_buff, src_buff, len);
return ANON_RESULT(len, continue_anon);
}
REGISTER_ANON (AnonBroadcastHandler);
}
pktanon-master/libpktanon/anonprimitives/AnonRandomize.h 0000644 0000000 0000000 00000001333 12701423271 022643 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_RANDOMIZE_H
# define PKTANON__ANON_RANDOMIZE_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonRandomize: public AnonPrimitive
{
public:
AnonRandomize();
virtual ~AnonRandomize();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const ;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
};
}
#endif // __ANON_RANDOMIZE_H
pktanon-master/libpktanon/anonprimitives/AnonShorten.cpp 0000644 0000000 0000000 00000002612 12701423271 022671 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonShorten.h"
#include "AnonFactory.h"
#include "log.h"
#include "debug.h"
#include
namespace pktanon
{
AnonShorten* AnonShorten::construct ( const Params& params )
{
if ( !params.has_param ( "newlen" ) )
throw std::runtime_error ( "incomplete configuration for AnonShorten: missing newlen attribute" );
unsigned int len = strtoul ( params.get_param ( "newlen" ).c_str(), nullptr, 10 );
_plg_verbose ( "\t\t\t" << "newlen: " << len );
return new AnonShorten ( len );
}
AnonShorten::AnonShorten ( unsigned int length ) :
newlen ( length )
{
}
AnonShorten::~AnonShorten()
{
}
AnonPrimitive::ANON_RESULT AnonShorten::anonymize_chain ( void* buf, unsigned int len ) const
{
// HB();
return ANON_RESULT ( std::min ( newlen, len ) );
}
AnonPrimitive::ANON_RESULT AnonShorten::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
// HB();
if ( newlen == 0 ) return ANON_RESULT ( 0 );
memcpy ( dst_buff, src_buff, std::min ( newlen, len ) );
return ANON_RESULT ( std::min ( newlen, len ) );
}
REGISTER_ANON_PARAM ( AnonShorten, AnonShorten::construct );
}
pktanon-master/libpktanon/anonprimitives/AnonHashHmacSha1_Nettle.cpp 0000644 0000000 0000000 00000005544 12701423271 024762 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonHashHmacSha1.h"
#include "AnonFactory.h"
#include
#include
namespace pktanon
{
AnonHashHmacSha1* AnonHashHmacSha1::construct ( const Params& params )
{
if ( !params.has_param ( "key" ) )
throw std::runtime_error ( "incomplete configuration for AnonHashHmacSha1: missing key attribute" );
return new AnonHashHmacSha1 ( params.get_param ( "key" ) );
}
AnonHashHmacSha1::AnonHashHmacSha1 ( string hmackey )
{
keylen = ( unsigned int ) hmackey.length();
key = new uint8_t[keylen + 1];
#ifdef WIN32
strcpy ( ( char* ) key, hmackey.c_str () );
#else
strcpy ( ( char* ) key, hmackey.c_str() );
#endif
}
AnonHashHmacSha1::~AnonHashHmacSha1()
{
delete[] key;
}
AnonPrimitive::ANON_RESULT AnonHashHmacSha1::anonymize_chain ( void* buf, unsigned int len ) const
{
struct hmac_sha1_ctx hmac_ctx;
hmac_sha1_set_key ( &hmac_ctx, keylen, key );
hmac_sha1_update ( &hmac_ctx, len, ( unsigned char* ) buf );
hmac_sha1_digest ( &hmac_ctx, std::min ( ( int ) len, SHA1_DIGEST_SIZE ), ( unsigned char* ) buf );
if ( SHA1_DIGEST_SIZE >= len )
{
return ANON_RESULT ( std::min ( ( int ) len, SHA1_DIGEST_SIZE ) );
}
// HmacSha1::sha1_hmac ( (uint8_t*) &digest, key, keylen, (uint8_t*) buf, len);
int remaining = len;
int pos = 0;
while ( remaining > 0 )
{
memcpy ( ( unsigned char* ) buf + pos, buf, std::min ( remaining, SHA1_DIGEST_SIZE ) );
remaining -= SHA1_DIGEST_SIZE;
pos += SHA1_DIGEST_SIZE;
} // while (remaining != 0)
return ANON_RESULT ( len );
}
AnonPrimitive::ANON_RESULT AnonHashHmacSha1::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
struct hmac_sha1_ctx hmac_ctx;
nettle_hmac_sha1_set_key ( &hmac_ctx, keylen, key );
nettle_hmac_sha1_update ( &hmac_ctx, len, ( unsigned char* ) src_buff );
nettle_hmac_sha1_digest ( &hmac_ctx, std::min ( ( int ) len, SHA1_DIGEST_SIZE ), ( unsigned char* ) dst_buff );
if ( SHA1_DIGEST_SIZE >= len )
{
return ANON_RESULT ( std::min ( ( int ) len, SHA1_DIGEST_SIZE ) );
}
// HmacSha1::sha1_hmac ( (uint8_t*) &digest, key, keylen, (uint8_t*) buf, len);
int remaining = len;
int pos = 0;
while ( remaining > 0 )
{
memcpy ( ( unsigned char* ) dst_buff + pos, dst_buff, std::min ( remaining, SHA1_DIGEST_SIZE ) );
remaining -= SHA1_DIGEST_SIZE;
pos += SHA1_DIGEST_SIZE;
} // while (remaining != 0)
return ANON_RESULT ( len );
}
REGISTER_ANON_PARAM ( AnonHashHmacSha1, AnonHashHmacSha1::construct );
}
pktanon-master/libpktanon/anonprimitives/AnonPrimitive.h 0000644 0000000 0000000 00000002777 12701423271 022700 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_PRIMITIVE_H
#define PKTANON__ANON_PRIMITIVE_H
#include
using std::string;
using std::min;
namespace pktanon
{
class Params;
class AnonPrimitive
{
public:
AnonPrimitive();
virtual ~AnonPrimitive();
AnonPrimitive(const AnonPrimitive& other) = delete;
AnonPrimitive& operator= (const AnonPrimitive& other) = delete;
unsigned int anonimyze(const void* const src_buff, void* dst_buff, unsigned int len) const;
AnonPrimitive* getNext() const;
void setNext(AnonPrimitive* nextprim);
protected:
struct ANON_RESULT
{
unsigned int newlength;
bool call_next_anon;
ANON_RESULT() : newlength(0), call_next_anon(false) { }
ANON_RESULT(unsigned int newlength, bool call_next_anon = true) : newlength(newlength), call_next_anon(call_next_anon) {}
ANON_RESULT& operator&=(const ANON_RESULT& rhs)
{
newlength = std::min(newlength, rhs.newlength);
call_next_anon &= rhs.call_next_anon;
return *this;
}
};
virtual ANON_RESULT anonymize_internal(const void* const src_buff, void* dst_buff, unsigned int len) const;
virtual ANON_RESULT anonymize_chain(void* buf, unsigned int len) const = 0;
private:
AnonPrimitive* next;
};
}
#endif // __ANON_PRIMITIVE_H
pktanon-master/libpktanon/anonprimitives/AnonHashSha256.h 0000644 0000000 0000000 00000001434 12701423271 022471 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANONHASHSHA256_H
#define PKTANON__ANONHASHSHA256_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonHashSha256 : public AnonPrimitive
{
public:
AnonHashSha256 ( bool truncate = false );
virtual ~AnonHashSha256() = default;
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const ;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
private:
bool truncate;
};
}
#endif // ANONHASHSHA256_H
pktanon-master/libpktanon/anonprimitives/AnonHashHmacSha1.h 0000644 0000000 0000000 00000001575 12701423271 023114 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_HASH_HMAC_SHA1_H
#define PKTANON__ANON_HASH_HMAC_SHA1_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonHashHmacSha1: public AnonPrimitive
{
public:
static AnonHashHmacSha1* construct ( const pktanon::Params& attrmap );
AnonHashHmacSha1 ( string hmackey );
virtual ~AnonHashHmacSha1();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const ;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
private:
uint8_t* key;
unsigned short keylen;
};
}
#endif // PKTANON__ANON_HASH_HMAC_SHA1_H
pktanon-master/libpktanon/anonprimitives/AnonConstOverwrite.h 0000644 0000000 0000000 00000001571 12701423271 023714 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_CONST_OVERWRITE_H
#define PKTANON__ANON_CONST_OVERWRITE_H
#include "AnonPrimitive.h"
namespace pktanon
{
class Params;
class AnonConstOverwrite: public AnonPrimitive
{
public:
static AnonConstOverwrite* construct ( const Params& params );
AnonConstOverwrite ( unsigned char byte );
virtual ~AnonConstOverwrite();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
private:
unsigned char byteval;
};
}
#endif // __ANON_CONST_OVERWRITE_H
pktanon-master/libpktanon/anonprimitives/AnonIdentity.cpp 0000644 0000000 0000000 00000001503 12701423271 023036 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonIdentity.h"
#include
#include
//--------------------------------------------
namespace pktanon
{
AnonIdentity::AnonIdentity() {}
AnonIdentity::~AnonIdentity() = default;
AnonPrimitive::ANON_RESULT AnonIdentity::anonymize_chain(void* buf, unsigned int len) const
{
return ANON_RESULT(len);
}
AnonPrimitive::ANON_RESULT AnonIdentity::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
memcpy(dst_buff, src_buff, len);
return ANON_RESULT(len);
}
REGISTER_ANON(AnonIdentity)
}
pktanon-master/libpktanon/anonprimitives/AnonKnownProtocolHandler.h 0000644 0000000 0000000 00000001422 12701423271 025026 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_ANONKNOWNPROTOCOLHANDLER_H
#define PKTANON_ANONKNOWNPROTOCOLHANDLER_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonKnownProtocolHandler : public AnonPrimitive
{
public:
AnonKnownProtocolHandler();
virtual ~AnonKnownProtocolHandler();
protected:
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
};
}
#endif // PKTANON_ANONKNOWNETHERTYPEHANDLER_H
pktanon-master/libpktanon/anonprimitives/AnonShuffle.h 0000644 0000000 0000000 00000001303 12701423271 022304 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_SHUFFLE_H
#define PKTANON__ANON_SHUFFLE_H
#include "AnonPrimitive.h"
namespace pktanon
{
class AnonShuffle: public AnonPrimitive
{
public:
AnonShuffle();
virtual ~AnonShuffle();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
};
}
#endif // __ANON_SHUFFLE_H
pktanon-master/libpktanon/anonprimitives/AnonCryptoPan.h 0000644 0000000 0000000 00000001576 12701423271 022643 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_CRYPTO_PAN_H
#define PKTANON__ANON_CRYPTO_PAN_H
# include "AnonPrimitive.h"
# include "cryptopan/panonymizer.h"
namespace pktanon
{
class AnonCryptoPan: public AnonPrimitive
{
public:
static AnonCryptoPan* construct ( Params& params );
AnonCryptoPan ( std::string _key );
virtual ~AnonCryptoPan();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const ;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
private:
std::string key;
PAnonymizer cryptopan;
};
}
#endif // PKTANON__ANON_CRYPTO_PAN_H
pktanon-master/libpktanon/anonprimitives/AnonWhitenoise.cpp 0000644 0000000 0000000 00000004515 12701423271 023371 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonWhitenoise.h"
#include "AnonFactory.h"
#include
#include "RandomNumberGenerator.h"
namespace pktanon
{
AnonWhitenoise* AnonWhitenoise::construct ( const Params& params )
{
if ( !params.has_param ( "strength" ) )
throw std::runtime_error ( "incomplete configuration for AnonWhitenoise: missing strength attribute" );
unsigned char istrength = std::strtoul ( params.get_param ( "strength" ).c_str(), nullptr, 10 );
return new AnonWhitenoise ( istrength );
}
AnonWhitenoise::AnonWhitenoise ( unsigned char strengthval ) :
strength ( strengthval )
{
}
AnonWhitenoise::~AnonWhitenoise()
{
}
AnonPrimitive::ANON_RESULT AnonWhitenoise::anonymize_chain ( void* buf, unsigned int len ) const
{
// how many bits are in the buffer?
unsigned int bits = len * 8;
// how many bits of these will we flip? Generate a random number and apply the given strength.
unsigned int randbits = RandomNumberGenerator::generate ( 0, bits );
randbits = ( unsigned int ) ceil (
( ( double ) randbits / 100.0 ) * ( strength * 10 ) );
// in any case we will flip at least one bit, if we have any bits
if ( bits > 0 && randbits == 0 )
randbits++;
//
// now we flip randbits in the buffer at random positions
//
unsigned int flipbit;
unsigned char* byte;
unsigned char mask;
for ( unsigned int i = 0; i < randbits; i++ )
{
flipbit = RandomNumberGenerator::generate ( 0, bits - 1 );
byte = ( ( unsigned char* ) buf ) + ( flipbit / 8 );
mask = 1 << ( flipbit % 8 );
if ( ( *byte & mask ) == 0 )
*byte |= mask; // set bit to 1
else
*byte &= ~mask; // set bit to 0
} // for (unsigned int i=0; i
#include
namespace pktanon
{
AnonBytewise::AnonBytewise()
{
}
AnonBytewise::AnonBytewise ( const AnonBytewise& other ) : AnonPrimitive ( other )
{
memcpy ( anonbytes, other.anonbytes, 256*sizeof ( unsigned char ) );
}
AnonBytewise::~AnonBytewise()
{
}
AnonPrimitive::ANON_RESULT AnonBytewise::anonymize ( void* buf, unsigned int len )
{
unsigned char* pnt;
for ( unsigned int i = 0; i < len; i++ )
{
pnt = ( unsigned char* ) buf + i;
memset ( pnt, anonbytes[*pnt], 1 );
} // for (unsigned int i=0; inext;
while ( unlikely ( next && result.call_next_anon ) )
{
result &= next->anonymize_chain ( dst_buff, result.newlength );
next = next->getNext();
}
return result.newlength;
}
AnonPrimitive::ANON_RESULT AnonPrimitive::anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const
{
memcpy(dst_buff, src_buff, len);
return anonymize_chain(dst_buff, len);
}
}
pktanon-master/libpktanon/anonprimitives/AnonShorten.h 0000644 0000000 0000000 00000001774 12701423271 022346 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_SHORTEN_H
# define PKTANON__ANON_SHORTEN_H
#include "AnonPrimitive.h"
namespace pktanon
{
/**
* shortens the buffer.
*
* if the parameter 'length' is 0, buffer is completely removed
* if the parameter 'length' is larger than the size of the buffer, buffer is unchanged
*/
class AnonShorten: public AnonPrimitive
{
public:
static AnonShorten* construct ( const pktanon::Params& params );
AnonShorten ( unsigned int length );
virtual ~AnonShorten();
protected:
virtual ANON_RESULT anonymize_chain ( void* buf, unsigned int len ) const;
virtual ANON_RESULT anonymize_internal ( const void*const src_buff, void* dst_buff, unsigned int len ) const;
private:
unsigned int newlen;
};
}
#endif // __ANON_SHORTEN_H
pktanon-master/libpktanon/PktAnon.cpp 0000644 0000000 0000000 00000005005 12701423271 016735 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "PktAnon.h"
#include
#include
#include "ConfigSAXParser.h"
#include "transformations/Transformation.h"
#include "transformations/TransformationsConfigurator.h"
#include "transformations/ErrorCodes.h"
#include "RandomNumberGenerator.h"
#include "log.h"
#include "debug.h"
#ifdef NOXMLCONFIG
#include "HardCodedConfig.h"
#endif
namespace pktanon
{
// define global variables
bool log_initialization = false;
bool _plg_quiet = false;
bool _plg_verbose = false;
# ifdef TRACE_ENABLED
std::mutex dbg_mutex;
# endif
Transformation* PktAnon::link_layer_transformation = nullptr;
void PktAnon::initialize ( std::string config_filename )
{
_plg_info ( "initializing PktAnon, configuration = " << config_filename );
_plg_verbose ( "parsing configuration file..." );
PktAnonConfig config;
# ifndef NOXMLCONFIG
try
{
ConfigSAXParser::instance().parseConfigFromFile ( config_filename, config);
}
catch ( std::exception& e )
{
_plg_error ( "failed to parse configuration: " << e.what() );
throw e;
}
ConfigSAXParser::destroy();
_plg_verbose ( "parsed configuration file." );
_plg_verbose ( "configuring transformations..." );
# else
// TODO fix this
/*config =*/ HardCodedConfig::fill_pktanon_config();
# endif
auto& tc = TransformationsConfigurator::instance();
tc.configure_packet_transformations(config);
tc.configure_transformations_lookups();
// TransformationsConfigurator::destroy();
RandomNumberGenerator::init();
_plg_verbose ( "configured" );
}
bool PktAnon::set_link_type ( uint32_t link_type ) noexcept
{
// TRACEV(link_type);
link_layer_transformation = Transformation::getTransformationLinktype ( link_type );
return link_layer_transformation != nullptr;
}
int PktAnon::transform_packet ( const std::uint8_t* source_buffer, std::uint8_t* destination_buffer, unsigned int max_packet_length ) noexcept
{
assert ( link_layer_transformation != nullptr );
return link_layer_transformation->transform ( source_buffer, destination_buffer, max_packet_length );
}
int PktAnon::get_erroneus_packet_length ( int packet_length )
{
return GET_LENGTH_VALUE(packet_length);
}
const char* PktAnon::get_error_string ( const int packet_length )
{
return GET_ERROR_STRING(packet_length);
}
}
pktanon-master/libpktanon/RandomNumberGenerator.h 0000644 0000000 0000000 00000001274 12701423271 021274 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef __RANDOM_NUMBER_GENERATOR_H
#define __RANDOM_NUMBER_GENERATOR_H
#include
#include
namespace pktanon
{
class RandomNumberGenerator
{
public:
static void init();
static unsigned int generate (unsigned int rangemin, unsigned int rangemax);
static void generate_random_bytes (uint8_t* buffer, size_t length);
private:
static std::random_device engine;
};
}
#endif // __RANDOM_NUMBER_GENERATOR_H
pktanon-master/libpktanon/PktAnonConfig.h 0000644 0000000 0000000 00000010375 12701423271 017536 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_PKTANONCONFIG_H
#define PKTANON_PKTANONCONFIG_H
# include
# include
# include
# include
# include
# include "Params.h"
namespace pktanon
{
struct io_config;
/**
* PktAnon Configuration
*/
class PktAnonConfig
{
public:
~PktAnonConfig();
PktAnonConfig();
// structures
class AnonConfig
{
public:
AnonConfig() {};
AnonConfig(std::string&& anon_class, Params&& attributes) :
anon_class(std::move(anon_class)), anon_params(std::move(attributes))
{};
const std::string& get_anon_class() const { return anon_class;};
const Params& get_anon_params() const { return anon_params;};
private:
friend class PktAnonConfig;
std::string anon_class;
Params anon_params;
};
class PacketConfig
{
public:
PacketConfig(std::string&& protocol) : protocol(std::move(protocol)) {}
const std::string& get_protocol() const {return protocol;}
bool has_field(const std::string& field_name) const { return fields.find(field_name) != fields.end();}
const std::vector& get_anon_config(const std::string& field_name) const {
assert(has_field(field_name));
return (*fields.find(field_name)).second;
}
private:
friend class PktAnonConfig;
const std::string protocol;
std::unordered_map> fields;
};
// reading
const Params& get_global_parameters() const {return global_parameters;};
// const std::string& get_input_type() const;
// const Params& get_input_params() const;
// const std::string& get_output_type() const;
// const Params& get_output_params() const;
const std::vector& get_packets() const {return packets;};
static bool has_value(const std::string& param_value, const std::string&& expected_value) { return param_value.compare(expected_value) == 0;}
// modification
void add_global_param(std::string&& key, std::string&& value);
// void set_input_type(std::string&& type);
// void add_input_param(std::string&& key, std::string&& value);
// void set_output_type(std::string&& type);
// void add_output_param(std::string&& key, std::string&& value);
void add_packet(std::string&& protocol);
void add_field_to_last_added_packet(std::string&& field_name);
void add_field_to_last_added_packet(std::string&& field_name, AnonConfig&& anon_config);
void add_anon_to_field_to_last_added_packet(const std::string& field_name, AnonConfig&& anon_config);
static void set_anon_class(AnonConfig& anon_config, std::string&& class_name);
static void add_anon_param(AnonConfig& anon_config, std::string&& param_name, std::string&& param_value);
private:
// io_config* input_config;
// io_config* output_config;
Params global_parameters;
std::vector packets;
};
// inline std::ostream& operator<<(std::ostream& os, PktAnonConfig& cfg)
// {
// os << "PacketAnon Configuration: " << std::endl;
// os << "\tinput file name: " << cfg.input_file << std::endl;
// os << "\toutput file name: " << cfg.output_file << std::endl;
// os << "\tparameters(size = " << cfg.parameters.size() << "): " << std::endl;
// for (auto& param : cfg.parameters)
// {
// os << "\t\t" << param.first << ": " << param.second << std::endl;
// }
// os << "\tpackets configuration(size = " << cfg.packets.size() << "): " << std::endl;
// for (auto& pkt : cfg.packets)
// {
// os << "\t\t" << pkt.pkt_name << " (fieldsnum= " << pkt.fields.size() << "):"<< std::endl;
// for (auto& field: pkt.fields)
// {
// os << "\t\t\t" << field.first << std::endl;
// for (auto& anon: field.second)
// {
// os << "\t\t\t\t" << anon.anon_class << std::endl;
// for (auto& attr: anon.attributes)
// {
// os << "\t\t\t\t\t" << attr.first << ": " << attr.second << std::endl;
// }
// }
// }
// }
//
// return os;
// }
}
#endif // PKTANON_PKTANONCONFIG_H
pktanon-master/libpktanon/optmacros.h 0000644 0000000 0000000 00000000337 12701423271 017042 0 ustar root root #ifndef PKTANON_OPTMACROS_H
#define PKTANON_OPTMACROS_H
namespace pktanon {
// branch predictions
# define unlikely(expr) __builtin_expect(!!(expr), 0)
# define likely(expr) __builtin_expect(!!(expr), 1)
}
#endif
pktanon-master/libpktanon/RandomNumberGenerator.cpp 0000644 0000000 0000000 00000001741 12701423271 021626 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "RandomNumberGenerator.h"
#include
#include
using namespace pktanon;
std::random_device RandomNumberGenerator::engine;
void RandomNumberGenerator::init()
{
// DO NOTHING
}
unsigned int RandomNumberGenerator::generate (unsigned int min, unsigned int max)
{
std::uniform_int_distribution dist (min, max);
return dist (engine);
}
void RandomNumberGenerator::generate_random_bytes (uint8_t* buffer, size_t length)
{
std::uniform_int_distribution distribution (0, 0xff);
for(int j = 0; j < length ; j++)
{
buffer[j] = distribution(engine);
}
// std::generate (buffer, buffer + length, [distribution,engine]() {return distribution (engine);});
}
pktanon-master/libpktanon/PHF.h 0000644 0000000 0000000 00000004676 12701423271 015462 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_PHF_H
#define PKTANON_PHF_H
# include
#include
#include
#include
#include
#include
namespace pktanon
{
static const unsigned prime = 31;
/// family of functions h = ((a*key + b) mod p) mod size
/// see Ramakrishna, M. V. "A Simple Perfect Hashing Method for Static Sets." ICCI. 1992.
unsigned int phf_family(unsigned a, unsigned b, unsigned size, unsigned key)
{
// size will be power of two
// return ((a * key + b) % prime ) % size;
return ((a * key + b) % prime ) & (size - 1);
}
std::size_t round_to_pow2(std::size_t size)
{
// check if size is a power of two (http://graphics.stanford.edu/~seander/bithacks.html#ModulusDivisionEasy)
if ((size & (size - 1)) == 0)
{
return size;
}
// round to the pow2
size--;
size |= size >> 1;
size |= size >> 2;
size |= size >> 4;
size |= size >> 8;
size |= size >> 16;
size++;
return size;
}
template
std::function generate_phf(std::unordered_map& keys_values, std::size_t& table_size)
{
if (keys_values.size() == 0)
{
table_size = 0;
return [](unsigned key) {return 0;};
}
// round size to the next power of two
table_size = round_to_pow2(keys_values.size());
// TRACEV(table_size);
// calculate a and b
std::set hashes;
std::function h;
unsigned a_0 = 1;
unsigned b_0 = 0;
unsigned size = table_size;
for (unsigned a = a_0; a <= prime; a++)
{
for (unsigned b = b_0; b <= prime; b++)
{
hashes.clear();
bool collision = false;
h = std::bind(phf_family, a, b, size, std::placeholders::_1);
for (auto& key_value_pair: keys_values)
{
auto hash = h(key_value_pair.first);
if (hashes.find(hash) == hashes.end())
{
hashes.insert(hash);
}
else
{
collision = true;
break;
}
}
if (!collision)
{
// TRACEV(a);
// TRACEV(b);
// TRACEV(size);
return h;
}
}
}
throw std::runtime_error("phf not found");
}
}
#endif // PKTANON_PHF_H
pktanon-master/libpktanon/AnonFactory.h 0000644 0000000 0000000 00000002742 12701423271 017260 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON__ANON_FACTORY_H
#define PKTANON__ANON_FACTORY_H
# include
# include
# include
# include "anonprimitives/AnonPrimitive.h"
#include "Params.h"
namespace pktanon
{
#define REGISTER_ANON(TYPE) \
AnonFactory::creator TYPE##creator(#TYPE, [](const Params& params) {return new TYPE();});
#define REGISTER_ANON_PARAM(TYPE, FUNC) \
AnonFactory::creator TYPE##creator(#TYPE, FUNC);
class AnonFactory
{
public:
AnonFactory();
~AnonFactory();
typedef std::function AnonConstructor;
static void register_anon(string anon_name, AnonConstructor constructor);
// static AnonPrimitive* create_anon(std::string&& anon_name, std::unordered_map attrmap);
static AnonPrimitive* create_anon(const std::string& anon_name, const Params& params);
struct creator
{
creator(std::string anon_name, AnonConstructor constructor)
{
register_anon(anon_name, constructor);
}
};
static std::unordered_map& get_mappings()
{
static std::unordered_map mappings;
return mappings;
}
private:
};
}
#endif // PKTANON__ANON_FACTORY_H
pktanon-master/libpktanon/PktAnonConfig.cpp 0000644 0000000 0000000 00000005712 12701423271 020070 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "PktAnonConfig.h"
#include "debug.h"
namespace pktanon
{
struct io_config
{
std::string type;
Params params;
};
PktAnonConfig::~PktAnonConfig()
{
// delete input_config;
// delete output_config;
}
PktAnonConfig::PktAnonConfig() /*:*/
// input_config(new io_config()), output_config(new io_config())
{ }
//getters ------------------------------------------------------------
// const std::string& PktAnonConfig::get_input_type() const { return input_config->type; }
// const Params& PktAnonConfig::get_input_params() const { return input_config->params; }
// const std::string& PktAnonConfig::get_output_type() const { return output_config->type; }
// const Params& PktAnonConfig::get_output_params() const { return output_config->params; }
//setters ------------------------------------------------------------
# define ADD_PARAM(KEY, VALUE) add_param(std::move(KEY), std::move(VALUE))
void PktAnonConfig::add_global_param ( std::string&& key, std::string&& value )
{
global_parameters.ADD_PARAM ( key, value );
}
// void PktAnonConfig::set_input_type(std::string&& type)
// {
// input_config->type = type.data();
// }
//
// void PktAnonConfig::add_input_param(std::string&& key, std::string&& value)
// {
// input_config->params.ADD_PARAM(key, value);
// }
//
//
// void PktAnonConfig::set_output_type(std::string&& type)
// {
// output_config->type = type;
// }
//
// void PktAnonConfig::add_output_param(std::string&& key, std::string&& value)
// {
// output_config->params.ADD_PARAM(key, value);
// }
void PktAnonConfig::add_packet ( std::string&& protocol )
{
packets.emplace_back ( std::move ( protocol ) );
}
void PktAnonConfig::add_field_to_last_added_packet ( std::string&& field_name )
{
assert ( packets.size() > 0 );
packets[packets.size() - 1].fields[field_name] = std::vector();
}
void PktAnonConfig::add_field_to_last_added_packet ( std::string&& field_name, PktAnonConfig::AnonConfig&& anon_config )
{
packets[packets.size() - 1].fields[field_name] = std::vector();
packets[packets.size() - 1].fields[field_name].emplace_back ( anon_config );
}
void PktAnonConfig::set_anon_class ( AnonConfig& anon_config, std::string&& class_name )
{
anon_config.anon_class = std::move ( class_name );
}
void PktAnonConfig::add_anon_param ( PktAnonConfig::AnonConfig& anon_config, std::string&& param_name, std::string&& param_value )
{
anon_config.anon_params.add_param ( std::move ( param_name ), std::move ( param_value ) );
}
void PktAnonConfig::add_anon_to_field_to_last_added_packet ( const std::string& field_name, pktanon::PktAnonConfig::AnonConfig&& anon_config )
{
packets[packets.size() - 1].fields[field_name].emplace_back ( anon_config );
}
}
pktanon-master/libpktanon/PHT.h 0000644 0000000 0000000 00000005255 12701423271 015472 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_PHT_H
#define PKTANON_PHT_H
// # include
# include
#include
# include
namespace pktanon
{
template
class PHT
{
public:
typedef std::pair pht_entry;
typedef std::function phf;
~PHT();
PHT();
PHT(phf h, std::size_t num_entries);
PHT(PHT&& other);
PHT(const PHT& other) = delete;
PHT& operator=(PHT& other) = delete;
PHT& operator=(PHT&& other);
void insert(Key key, Value value);
Value lookup(Key key, Value default_value) const;
bool contains(Key key) const;
private:
pht_entry* entries;
phf h;
};
template
PHT::~PHT()
{
delete[] entries;
}
template
PHT::PHT(phf h, std::size_t num_entries):
h(h), entries(new pht_entry[num_entries])
{
memset(entries, 0xff, num_entries * sizeof(pht_entry));
}
template
PHT::PHT(): h(), entries(nullptr)
{ }
template
PHT::PHT(PHT&& other):
h(other.h), entries(other.entries)
{
other.entries = nullptr;
}
template
PHT& PHT::operator=(PHT&& other)
{
h = other.h;
delete[] entries;
entries = other.entries;
other.entries = nullptr;
return *this;
}
//----------------------------------------------------------------------------------------------------------------------
template
void PHT::insert(Key key, Value value)
{
// TRACEV((int)key << " " << value);
auto index = h(key);
entries[index] = std::make_pair(key, value);
}
// template
// void PHT::insert_raw(size_t index, Key key, Value value)
// {
// // TRACE(index << " " << (int)key << " " << value);
// entries[index] = std::make_pair(key, value);
// }
template
Value PHT::lookup(Key key, Value default_value) const
{
auto index = h(key);
if (entries[index].first == key)
{
return entries[index].second;
}
else
{
return default_value;
}
}
template
bool PHT::contains(Key key) const
{
auto index = h(key);
// TRACEV((int)key);
// TRACEV((int)entries[index].first);
return (entries[index].first == key);
}
}
#endif // PKTANON_PHF_H
pktanon-master/libpktanon/HardCodedConfig.cpp 0000644 0000000 0000000 00000032442 12701423271 020333 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "HardCodedConfig.h"
#include "PktAnonConfig.h"
// #include "globals.h"
using namespace pktanon;
static PktAnonConfig::AnonConfig create_anon_identity_config()
{
PktAnonConfig::AnonConfig anon_config;
PktAnonConfig::set_anon_class(anon_config,"AnonIdentity");
return anon_config;
}
static PktAnonConfig::AnonConfig create_anon_shorten_config()
{
PktAnonConfig::AnonConfig anon_config;
PktAnonConfig::set_anon_class(anon_config,"AnonShorten");
PktAnonConfig::add_anon_param(anon_config,"newlen", "0");
return anon_config;
}
static PktAnonConfig::AnonConfig create_anon_hash_sha256_config()
{
PktAnonConfig::AnonConfig anon_config;
PktAnonConfig::set_anon_class(anon_config,"AnonHashSha256");
// PktAnonConfig::add_anon_param(anon_config,"newlen", "0");
return anon_config;
}
static PktAnonConfig::AnonConfig create_anon_white_noise_config()
{
PktAnonConfig::AnonConfig anon_config;
PktAnonConfig::set_anon_class(anon_config,"AnonWhitenoise");
PktAnonConfig::add_anon_param(anon_config,"strength", "4");
return anon_config;
}
static void config_identity(PktAnonConfig* config);
static void config_high(PktAnonConfig* config);
PktAnonConfig* HardCodedConfig::fill_pktanon_config()
{
// TODO
PktAnonConfig* conf = nullptr; // const_cast(&config);
////// input = file (filename)
// conf->set_input_type("file");
// conf->add_input_param("filename", "bigFlows.pcap");
// conf->add_input_param("filename", "smallFlows.pcap");
// conf->add_input_param("filename", "traces/ipv6trace.pcap");
// conf->add_input_param("filename", "traces/file.pcap"); // linux-coocked-captures
// conf->add_input_param("filename", "traces/iptest.pcap"); // something small
// conf->add_input_param("filename", "traces/arp_big.pcap"); // something small
// conf->add_input_param("filename", "-");
///// input = live libpcap capture
// conf->set_input_type("libpcap-live");
// conf->add_input_param("interface", "enp2s1"); // interface name/any
// conf->add_input_param("filter", "tcp"); // filter (as in tcpdump or wireshark)
// conf->add_input_param("promiscuous", "yes"); // requires specififed value for interface
// conf->add_input_param("pcap-timeout", 1000); // timeout value for pcap_open_life
// conf->set_input_type("socket-raw");
// conf->add_input_param("interface", "enp2s1"); // name/any (no auto!)
// conf->add_input_param("promiscuous", "yes"); // requires specififed value for interface
// conf->set_output_type("file");
// conf->add_output_param("filename", "out.pcap");
// conf->add_output_param("flush-after-burst", "yes");
// conf->add_output_param("filename", "-");
// conf->set_output_type("libpcap-file");
// conf->add_output_param("filename", "out.pcap");
// conf->add_output_param("flush-after-burst", "yes");
// conf->set_output_type("libpcap-inject");
// conf->add_output_param("interface", "enp2s1"); // filter (as in tcpdump or wireshark)
// conf->set_output_type("socket");
// conf->add_output_param("use-ipv6", "yes"); // yes|no (default no)
// conf->add_output_param("protocol", "udp"); // yes|no (default no)
// conf->add_output_param("dst-host", "::1");
// conf->add_output_param("dst-port", "19009");
// make sure that ethernet payload is at least 46 bytes
conf->add_global_param("pad-ethernet-packets", "never"); // always,keep-length,never
conf->add_global_param("recalculate-ipv4-header-checksum", "yes"); // yes/no
// ip and ipv6 will call checksum methods on PseudoheaderAwareTransformations
conf->add_global_param("recalculate-payload-checksums", "yes"); // yes/no
// don't read more than @value@ bytes from input source for each packet
conf->add_global_param("pkt-burst-size", "32"); // numerical values
conf->add_global_param("pkt-burst-timeout", "1000"); // numerical values
conf->add_global_param("trim-input-packets", "256"); // numerical values
//----------------------------------------------------------------------------
// execution model selection
// conf->add_global_param("multiple-threads", "yes"); // disable concurrency
conf->add_global_param("threads-number", "1"); // auto == std::thread::hardware_concurrency()
// conf->add_global_param("separate-input-thread", "no"); // auto == separate thread for live sources
conf->add_global_param("separate-output-thread", "no"); // auto == no
//----------------------------------------------------------------------------
// execution model configuration (env_config)
//----------------------------------------------------------------------------
// config_identity(conf);
config_high(conf);
return conf;
}
void config_identity(PktAnonConfig* config)
{
config->add_packet("ethernet");
config->add_field_to_last_added_packet("mac-source", create_anon_identity_config());
config->add_field_to_last_added_packet("mac-dest", create_anon_identity_config());
config->add_field_to_last_added_packet("ethertype", create_anon_identity_config());
config->add_packet("linux_sll");
config->add_field_to_last_added_packet("packet-type", create_anon_identity_config());
config->add_field_to_last_added_packet("ll-address-type", create_anon_identity_config());
config->add_field_to_last_added_packet("ll-address", create_anon_identity_config());
config->add_field_to_last_added_packet("protocol", create_anon_identity_config());
config->add_packet("ipv4");
config->add_field_to_last_added_packet("tos", create_anon_identity_config());
config->add_field_to_last_added_packet("identification", create_anon_identity_config());
config->add_field_to_last_added_packet("flags", create_anon_identity_config());
config->add_field_to_last_added_packet("fragment", create_anon_identity_config());
config->add_field_to_last_added_packet("ttl", create_anon_identity_config());
config->add_field_to_last_added_packet("protocol", create_anon_identity_config());
config->add_field_to_last_added_packet("src-ip", create_anon_identity_config());
config->add_field_to_last_added_packet("dest-ip", create_anon_identity_config());
config->add_field_to_last_added_packet("options", create_anon_shorten_config());
/*
*/
config->add_packet("ipv6");
config->add_field_to_last_added_packet("traffic-class", create_anon_identity_config());
config->add_field_to_last_added_packet("flow-label", create_anon_identity_config());
config->add_field_to_last_added_packet("hop-limit", create_anon_identity_config());
config->add_field_to_last_added_packet("src-ip", create_anon_identity_config());
config->add_field_to_last_added_packet("dest-ip", create_anon_identity_config());
config->add_field_to_last_added_packet("next-header", create_anon_identity_config());
//
//
//
//
config->add_packet("udp");
config->add_field_to_last_added_packet("source-port", create_anon_identity_config());
config->add_field_to_last_added_packet("dest-port", create_anon_identity_config());
//
//
//
//
//
//
//
//
//
//
config->add_packet("tcp");
config->add_field_to_last_added_packet("source-port", create_anon_identity_config());
config->add_field_to_last_added_packet("dest-port", create_anon_identity_config());
config->add_field_to_last_added_packet("seq", create_anon_identity_config());
config->add_field_to_last_added_packet("ack", create_anon_identity_config());
config->add_field_to_last_added_packet("flags", create_anon_identity_config());
config->add_field_to_last_added_packet("window-size", create_anon_identity_config());
config->add_field_to_last_added_packet("urgent-pointer", create_anon_identity_config());
config->add_field_to_last_added_packet("options", create_anon_shorten_config());
// payload must be present
config->add_packet("payload");
config->add_field_to_last_added_packet("payload", create_anon_shorten_config());
}
void config_high(PktAnonConfig* config)
{
config->add_packet("ethernet");
config->add_field_to_last_added_packet("mac-source", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("mac-dest", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("ethertype", create_anon_identity_config());
config->add_packet("linux_sll");
config->add_field_to_last_added_packet("packet-type", create_anon_identity_config());
config->add_field_to_last_added_packet("ll-address-type", create_anon_identity_config());
config->add_field_to_last_added_packet("ll-address", create_anon_identity_config());
config->add_field_to_last_added_packet("protocol", create_anon_identity_config());
config->add_packet("ipv4");
config->add_field_to_last_added_packet("tos", create_anon_identity_config());
config->add_field_to_last_added_packet("identification", create_anon_identity_config());
config->add_field_to_last_added_packet("flags", create_anon_identity_config());
config->add_field_to_last_added_packet("fragment", create_anon_identity_config());
config->add_field_to_last_added_packet("ttl", create_anon_identity_config());
config->add_field_to_last_added_packet("protocol", create_anon_identity_config());
config->add_field_to_last_added_packet("src-ip", create_anon_identity_config());
config->add_field_to_last_added_packet("dest-ip", create_anon_identity_config());
config->add_field_to_last_added_packet("options", create_anon_shorten_config());
/*
*/
config->add_packet("ipv6");
config->add_field_to_last_added_packet("traffic-class", create_anon_identity_config());
config->add_field_to_last_added_packet("flow-label", create_anon_identity_config());
config->add_field_to_last_added_packet("hop-limit", create_anon_identity_config());
config->add_field_to_last_added_packet("src-ip", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("dest-ip", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("next-header", create_anon_identity_config());
//
//
//
//
config->add_packet("udp");
config->add_field_to_last_added_packet("source-port", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("dest-port", create_anon_hash_sha256_config());
//
//
//
//
//
//
//
//
//
//
config->add_packet("tcp");
config->add_field_to_last_added_packet("source-port", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("dest-port", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("seq", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("ack", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("flags", create_anon_identity_config());
config->add_field_to_last_added_packet("window-size", create_anon_identity_config());
config->add_field_to_last_added_packet("urgent-pointer", create_anon_hash_sha256_config());
config->add_field_to_last_added_packet("options", create_anon_shorten_config());
// payload must be present
config->add_packet("payload");
config->add_field_to_last_added_packet("payload", create_anon_shorten_config());
}
pktanon-master/libpktanon/ProtocolUtils.h 0000644 0000000 0000000 00000001126 12701423271 017652 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_PROTOCOLUTILS_H
#define PKTANON_PROTOCOLUTILS_H
# include
namespace pktanon
{
static const unsigned int ETHERNET_MTU = 1500;
enum EtherTypes : uint16_t
{
ETHERTYPE_IP = 0x0800,
ETHERTYPE_ARP = 0x0806,
ETHERTYPE_IPV6 = 0x86DD,
ETHERTYPE_VLAN = 0x8100
};
}
#endif // PKTANON_PROTOCOLUTILS_H
pktanon-master/libpktanon/Checksum.h 0000644 0000000 0000000 00000001072 12701423271 016572 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_CHECKSUM_H
#define PKTANON_CHECKSUM_H
#include
#include
namespace pktanon
{
class Checksum
{
public:
Checksum() : sum(0) {};
void update(void* buffer, size_t length);
uint16_t final();
private:
uint32_t sum;
};
}
#endif // PKTANON_CHECKSUM_H
pktanon-master/libpktanon/log.h 0000644 0000000 0000000 00000001422 12701423271 015610 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_LOG_H
#define PKTANON_LOG_H
# include
namespace pktanon
{
extern bool _plg_quiet;
extern bool _plg_verbose;
# define LOG_STREAM std::cerr
# define _plg_error(val) \
LOG_STREAM << "error: " << val << std::endl;
# define _plg_warn(val) \
LOG_STREAM << "warning: " << val << std::endl;
# define _plg_info(val) \
if (!_plg_quiet) {LOG_STREAM << val << std::endl;}
# define _plg_verbose(val) \
if (_plg_verbose) {LOG_STREAM << val << std::endl;}
}
#endif // PKTANON_LOG_H
pktanon-master/libpktanon/ConfigSAXParser.cpp 0000644 0000000 0000000 00000017164 12701423271 020332 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "ConfigSAXParser.h"
//----------------------------------------------------------------
#include
#include "debug.h"
#include
#include
#include
#include
using namespace xercesc;
namespace pktanon
{
class ConfigParserHandler : public xercesc::DefaultHandler
{
public:
virtual ~ConfigParserHandler();
ConfigParserHandler(PktAnonConfig& config);
void startElement (
const XMLCh* const uri,
const XMLCh* const localname,
const XMLCh* const qname,
const xercesc::Attributes& attrs
);
virtual void endElement ( const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname );
virtual void characters ( const XMLCh* const chars, const XMLSize_t length );
void fatalError ( const xercesc::SAXParseException& );
private:
PktAnonConfig& config;
std::string last_field_name;
size_t current_element;
std::string param_name;
};
ConfigParserHandler::ConfigParserHandler( PktAnonConfig& config ) :
config ( config )
{ }
ConfigParserHandler::~ConfigParserHandler() = default;
const size_t element_hash_base = 512;
const size_t e_PKTANON_config = 195;
const size_t e_parameters = 439;
const size_t e_param = 51;
const size_t e_anonymizations = 122;
const size_t e_packet = 36;
const size_t e_field = 152;
const size_t e_anon = 184;
void ConfigParserHandler::startElement ( const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname, const xercesc_3_1::Attributes& attrs )
{
XMLString::lowerCase ( const_cast ( localname ) );
size_t element = XMLString::hash ( localname, element_hash_base );
XMLCh* attr_NAME = XMLString::transcode ( "name" );
XMLCh* attr_ANON = XMLString::transcode ( "anon" );
XMLCh* attr_TYPE = XMLString::transcode ( "type" );
current_element = element;
switch ( current_element )
{
case e_PKTANON_config: break;
case e_parameters: break;
case e_param:
{
param_name = XMLString::transcode ( attrs.getValue ( attr_NAME ) );
break;
}
case e_anonymizations: break;
case e_packet:
{
std::string packet_name = XMLString::transcode ( attrs.getValue ( ( XMLSize_t ) 0 ) );
config.add_packet ( std::move ( packet_name ) );
break;
}
case e_field:
{
if ( attrs.getLength() == 1 )
{
std::string field_name = XMLString::transcode ( attrs.getValue ( attr_NAME ) );
last_field_name = field_name;
config.add_field_to_last_added_packet ( std::move ( field_name ) );
}
else
{
std::string field_name;
PktAnonConfig::AnonConfig anon_config;
for ( XMLSize_t j = 0; j < attrs.getLength(); j++ )
{
std::string att1 = XMLString::transcode ( attrs.getLocalName ( ( XMLSize_t ) j ) );
std::string att2 = XMLString::transcode ( attrs.getValue ( ( XMLSize_t ) j ) );
auto* attr_name = attrs.getLocalName ( j );
auto* attr_value = attrs.getValue ( j );
if ( XMLString::compareString ( attr_NAME, attr_name ) == 0 )
{
field_name = std::string ( XMLString::transcode ( attr_value ) );
}
else if ( XMLString::compareString ( attr_ANON, attr_name ) == 0 )
{
config.set_anon_class ( anon_config, std::string ( XMLString::transcode ( attr_value ) ) );
}
else
{
config.add_anon_param ( anon_config, std::string ( XMLString::transcode ( attr_name ) ), std::string ( XMLString::transcode ( attr_value ) ) );
}
}
config.add_field_to_last_added_packet ( std::move ( field_name ), std::move ( anon_config ) );
}
break;
case e_anon:
{
PktAnonConfig::AnonConfig anon_config;
for ( XMLSize_t j = 0; j < attrs.getLength(); j++ )
{
std::string att1 = XMLString::transcode ( attrs.getLocalName ( ( XMLSize_t ) j ) );
std::string att2 = XMLString::transcode ( attrs.getValue ( ( XMLSize_t ) j ) );
auto* attr_name = attrs.getLocalName ( j );
auto* attr_value = attrs.getValue ( j );
if ( XMLString::compareString ( attr_NAME, attr_name ) == 0 )
{
config.set_anon_class ( anon_config, std::string ( XMLString::transcode ( attr_value ) ) );
}
else
{
config.add_anon_param ( anon_config, std::string ( XMLString::transcode ( attr_name ) ), std::string ( XMLString::transcode ( attr_value ) ) );
}
}
config.add_anon_to_field_to_last_added_packet ( last_field_name, std::move ( anon_config ) );
}
break;
default:
char* message = XMLString::transcode ( localname );
PRINT ( "unknown element: " << message << ": " << element );
XMLString::release ( &message );
}
}
}
void ConfigParserHandler::endElement ( const XMLCh* const uri, const XMLCh* const localname, const XMLCh* const qname )
{
current_element = 0;
}
void ConfigParserHandler::characters ( const XMLCh* const chars, const XMLSize_t length )
{
switch ( current_element )
{
case e_param:
{
std::string param_value ( XMLString::transcode ( chars ) );
config.add_global_param ( std::move ( param_name ), std::move ( param_value ) );
}
}
current_element = 0;
}
void ConfigParserHandler::fatalError ( const xercesc::SAXParseException& exception )
{
throw exception;
// char* message = XMLString::transcode(exception.getMessage());
// throw std::runtime_error(std::string("Fatal Error: ") + message + " at line: " + std::to_string(exception.getLineNumber()));
}
//-------------------------------------------------------------------------------------------------------------
// ConfigParser
//-------------------------------------------------------------------------------------------------------------
ConfigSAXParser* ConfigSAXParser::pInstance = new ConfigSAXParser();
ConfigSAXParser::~ConfigSAXParser() = default;
ConfigSAXParser::ConfigSAXParser() {}
void ConfigSAXParser::parseConfigFromFile ( const std::string& filename, pktanon::PktAnonConfig& config )
{
try
{
XMLPlatformUtils::Initialize();
}
catch ( const XMLException& e )
{
char* message = XMLString::transcode ( e.getMessage() );
throw std::runtime_error ( message );
}
std::unique_ptr parser = std::unique_ptr ( XMLReaderFactory::createXMLReader() );
parser->setFeature ( XMLUni::fgSAX2CoreValidation, true );
parser->setFeature ( XMLUni::fgSAX2CoreNameSpaces, true ); // optional
ConfigParserHandler* config_parser = new ConfigParserHandler(config);
parser->setContentHandler ( config_parser );
parser->setErrorHandler ( config_parser );
try
{
parser->parse ( filename.c_str() );
}
catch ( const XMLException& e )
{
char* message = XMLString::transcode ( e.getMessage() );
throw std::runtime_error ( message );
}
catch ( const SAXParseException& e )
{
char* message = XMLString::transcode ( e.getMessage() );
throw std::runtime_error ( std::string ( "Fatal Error: " ) + message + " at line: " + std::to_string ( e.getLineNumber() ) );
}
catch ( const std::exception& e )
{
throw e;
}
catch ( ... )
{
throw std::runtime_error ( "unexpected exception at parseConfigFromFile" );
}
}
}
pktanon-master/libpktanon/Makefile.am 0000644 0000000 0000000 00000006270 12701423271 016720 0 ustar root root include $(top_srcdir)/include.mk
lib_LIBRARIES = libpktanon.a
###############################################################################
### pktanon library
###############################################################################
pktanon_sources = $(sources) $(transformation_sources) $(anonprim_sources) $(c_sources)
libpktanon_a_SOURCES = $(pktanon_sources)
# included anon primitives:
anonprim_sources =
anonprim_sources += AnonFactory.cpp
anonprim_sources += anonprimitives/AnonPrimitive.cpp
anonprim_sources += anonprimitives/AnonConstOverwrite.cpp
anonprim_sources += anonprimitives/AnonConstOverwriteRange.cpp
# anonprim_sources += anonprimitives/AnonContinuousChar.cpp
anonprim_sources += anonprimitives/AnonIdentity.cpp
anonprim_sources += anonprimitives/AnonRandomize.cpp
anonprim_sources += anonprimitives/AnonShorten.cpp
anonprim_sources += anonprimitives/AnonShuffle.cpp
anonprim_sources += anonprimitives/AnonWhitenoise.cpp
anonprim_sources += anonprimitives/AnonBroadcastHandler.cpp
anonprim_sources += anonprimitives/AnonKnownEthertypeHandler.cpp
anonprim_sources += anonprimitives/AnonKnownProtocolHandler.cpp
anonprim_sources += anonprimitives/cryptopan/rijndael.cpp
anonprim_sources += anonprimitives/cryptopan/panonymizer.cpp
anonprim_sources += anonprimitives/AnonCryptoPan.cpp
if USE_NETTLE
anonprim_sources += anonprimitives/AnonHashSha1_Nettle.cpp
anonprim_sources += anonprimitives/AnonHashSha256_Nettle.cpp
anonprim_sources += anonprimitives/AnonHashHmacSha1_Nettle.cpp
endif
if BYTEWISEHASHANONS
anonprim_sources += anonprimitives/AnonBytewise.cpp
anonprim_sources += anonprimitives/AnonBytewiseHashHmacSha1.cpp
anonprim_sources += anonprimitives/AnonBytewiseHashSha1.cpp
# anonprim_sources += anonprimitives/hmacsha1/sha1_hmac.cpp
endif
# included transformations:
transformation_sources =
transformation_sources += transformations/Transformation.cpp
transformation_sources += transformations/EthernetPacketTransformation.cpp
transformation_sources += transformations/VlanTagTransformation.cpp
transformation_sources += transformations/LinuxCookedCaptureTransformation.cpp
transformation_sources += transformations/ArpPacketTransformation.cpp
transformation_sources += transformations/IPv4PacketTransformation.cpp
transformation_sources += transformations/IPv6PacketTransformation.cpp
transformation_sources += transformations/UdpPacketTransformation.cpp
transformation_sources += transformations/TcpPacketTransformation.cpp
transformation_sources += transformations/IcmpPacketTransformation.cpp
transformation_sources += transformations/ICMPv6PacketTransformation.cpp
transformation_sources += transformations/PayloadTransformation.cpp
transformation_sources += transformations/TransformationsConfigurator.cpp
transformation_sources += transformations/DefaultTransformationsConfigurator.cpp
transformation_sources += transformations/ErrorCodes.cpp
sources =
# utilities:
sources += Checksum.cpp
sources += RandomNumberGenerator.cpp
# configuration:
sources += ConfigSAXParser.cpp
sources += PktAnonConfig.cpp
sources += PktAnon.cpp
# config for profiling:
sources += HardCodedConfig.cpp
# c sources:
c_sources =
c_sources += PktAnonC.cpp pktanon-master/libpktanon/AnonFactory.cpp 0000644 0000000 0000000 00000001620 12701423271 017605 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "AnonFactory.h"
#include
#include
#include "debug.h"
namespace pktanon
{
AnonFactory::~AnonFactory() { }
AnonFactory::AnonFactory() { }
void AnonFactory::register_anon(string anon_name, pktanon::AnonFactory::AnonConstructor constructor)
{
get_mappings().emplace(anon_name, constructor);
}
AnonPrimitive* AnonFactory::create_anon(const string& anon_name, const pktanon::Params& params)
{
auto constructor = get_mappings().find(anon_name);
if (constructor == get_mappings().end())
throw std::runtime_error("anon primitive " + anon_name + " not found");
return (*constructor).second(params);
}
}
pktanon-master/libpktanon/Params.h 0000644 0000000 0000000 00000007771 12701423271 016267 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
# ifndef PKTANON_PARAMS_H
# define PKTANON_PARAMS_H
# include
# include
namespace pktanon
{
enum class TFD_VAL {TRUE, FALSE, DEFAULT};
struct ID_VAL
{
ID_VAL() : int_val(0), is_default(true) {}
ID_VAL(unsigned long value) : int_val(value), is_default(false) {}
unsigned long int_val;
bool is_default;
};
# define THROW_MISSING_VAL(key) throw std::runtime_error(std::string("missing parameter: ") + key);
# define THROW_WRONG_VAL(key, wrong_value) throw std::runtime_error("illegal value for boolean parameter " + key + ": " + wrong_value);
/**
* wrapper arount hashtable (inspired by java.lang.Properties)
*/
class Params
{
public:
~Params() = default;
Params() :props() {};
// Params(Params&& other) : props(std::move(other.props)) {};
bool has_param(const std::string& key) const { return props.find(key) != props.end(); }
const std::string& get_param(const std::string& key) const
{
if (!has_param(key)) throw std::runtime_error(std::string("missing parameter: ") + key);
return (*props.find(key)).second;
}
const std::string& get_param(const std::string& key, const std::string& default_value) const
{
if (has_param(key)) return (*props.find(key)).second;
return default_value;
}
bool get_bool_param(const std::string& key) const
{
if (!has_param(key)) throw std::runtime_error(std::string("missing parameter: ") + key);
const auto& str_val = (*props.find(key)).second;
if (is_true_value(str_val)) { return true; }
else if (is_false_value(str_val)) { return false; }
else { THROW_WRONG_VAL(key, str_val); }
}
bool get_bool_param(const std::string& key, bool default_value) const
{
if (has_param(key)) { return get_bool_param(key); }
return default_value;
}
///param with values - true/false/default
TFD_VAL get_tfd_param(const std::string& key) const
{
if (!has_param(key)) return TFD_VAL::DEFAULT;
const auto& str_val = (*props.find(key)).second;
if (is_default_value(str_val)) {return TFD_VAL::DEFAULT;}
else if (is_true_value(str_val)) {return TFD_VAL::TRUE;}
else if (is_false_value(str_val)) {return TFD_VAL::FALSE;}
else {THROW_WRONG_VAL(key, str_val);}
}
unsigned long get_uint_param(const std::string& key) const
{
if (!has_param(key)) throw std::runtime_error(std::string("missing parameter: ") + key);
const auto& str_val = (*props.find(key)).second;
return std::stoul(str_val);
}
unsigned long get_uint_param(const std::string& key, unsigned long default_value) const
{
if (has_param(key)) { return get_uint_param(key); }
return default_value;
}
ID_VAL get_uintdefault_param(const std::string& key) const
{
if (!has_param(key)) return ID_VAL();
const auto& str_val = (*props.find(key)).second;
if (is_default_value(str_val)) {return ID_VAL();}
else { return ID_VAL(std::stoul(str_val)); }
}
bool is_missing_or_has_default_value(const std::string& key) const
{
if (!has_param(key)) return true;
const auto& str_val = (*props.find(key)).second;
if (is_default_value(str_val)) return true;
return false;
}
void add_param(const std::string&& key, const std::string&& value)
{
props.emplace(std::move(key), std::move(value));
}
private:
bool is_default_value(const std::string& value) const { return value.compare("auto") == 0 || value.compare("default") == 0;}
bool is_true_value(const std::string& value) const { return value.compare("yes") == 0 || value.compare("on") == 0 || value.compare("1") == 0;}
bool is_false_value(const std::string& value) const { return value.compare("no") == 0 || value.compare("off") == 0 || value.compare("0") == 0;}
std::unordered_map props;
};
}
# endif
pktanon-master/libpktanon/debug.h 0000644 0000000 0000000 00000002211 12701423271 016112 0 ustar root root #ifndef PKTANON_DEBUG_H
#define PKTANON_DEBUG_H
# ifdef TRACE_ENABLED
# include
# include
# include
namespace pktanon {
extern std::mutex dbg_mutex;
# define TRACE(x) \
do {std::lock_guard _(dbg_mutex); std::cout << std::dec << __FILE__ << ":" << __LINE__ << ": " << x << std::endl;} while (0);
# define TRACEV(x) \
do {std::lock_guard _(dbg_mutex); std::cout << std::dec << __FILE__ << ":" << __LINE__ << ": " << #x << '=' << x << std::endl;} while (0);
# define PRINT(x) \
do { std::lock_guard _(dbg_mutex);std::cout << x << std::endl;} while (0);
# define HB() \
do { std::lock_guard _(dbg_mutex);std::cout << __FILE__ << ":" << __LINE__ << ": " << __func__ << std::endl;} while (0);
}
// inline void display_hex(unsigned length, char *data)
// {
// unsigned i;
// uint8_t* data2 = reinterpret_cast(data);
//
// for (i = 0; i
#include
using namespace pktanon;
void Checksum::update(void* buffer, size_t length)
{
uint16_t* buff = (uint16_t*) buffer;
const unsigned buff_len = length / 2;
for (size_t nWords = (buff_len/4); nWords > 0; nWords-- )
{
sum += *buff++; sum += *buff++; sum += *buff++; sum += *buff++;
}
for (size_t nWords = (buff_len & 0x03) ; nWords > 0; nWords-- )
sum += *buff++;
if (unlikely(length & 1))
sum += *buff & htons(0xFF00);
}
uint16_t Checksum::final()
{
sum = (sum & 0xFFFF) + (sum >> 16);
sum = (sum & 0xFFFF) + (sum >> 16);
sum = ~sum;
return sum;
}
// #pragma GCC pop_options
// checksum algorithm
// u16 tcp_sum_calc(u16 len_tcp, u16 src_addr[],u16 dest_addr[], BOOL padding, u16 buff[])
// {
// u16 prot_tcp=6;
// u16 padd=0;
// u16 word16;
// u32 sum;
//
// // Find out if the length of data is even or odd number. If odd,
// // add a padding byte = 0 at the end of packet
// if (padding&1==1){
// padd=1;
// buff[len_tcp]=0;
// }
//
// //initialize sum to zero
// sum=0;
//
// // make 16 bit words out of every two adjacent 8 bit words and
// // calculate the sum of all 16 vit words
// for (i=0;i>16)
// sum = (sum & 0xFFFF)+(sum >> 16);
//
// // Take the one's complement of sum
// sum = ~sum;
//
// return ((unsigned short) sum);
// }
pktanon-master/libpktanon/HardCodedConfig.h 0000644 0000000 0000000 00000000761 12701423271 017777 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_HARDCODEDCONFIG_H
# define PKTANON_HARDCODEDCONFIG_H
namespace pktanon
{
class PktAnonConfig;
class HardCodedConfig
{
public:
static PktAnonConfig* fill_pktanon_config();
};
}
#endif // PKTANON_TESTCONFIG_H
pktanon-master/libpktanon/ConfigSAXParser.h 0000644 0000000 0000000 00000001336 12701423271 017771 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_CONFIGSAXPARSER_H
#define PKTANON_CONFIGSAXPARSER_H
#include "PktAnonConfig.h"
namespace pktanon
{
class ConfigSAXParser
{
public:
static ConfigSAXParser& instance()
{ return *pInstance; }
static void destroy()
{ delete pInstance; }
void parseConfigFromFile(const std::string& filename, PktAnonConfig& config);
private:
~ConfigSAXParser();
ConfigSAXParser();
static ConfigSAXParser* pInstance;
};
}
#endif // CONFIGPARSER_H
pktanon-master/libpktanon/PktAnonC.cpp 0000644 0000000 0000000 00000002267 12701423271 017047 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "PktAnonC.h"
#include
#include
#include
static pktanon::Transformation* link_layer_trans;
void PKTANON__initialize ( char* config_file, int verbose)
{
// if (verbose)
// pktanon::log_initialization = true;
pktanon::PktAnon::initialize(config_file);
}
int PKTANON__set_link_type ( uint32_t linktype )
{
return pktanon::PktAnon::set_link_type(linktype) ? 1 : 0;
}
int PKTANON__transform_packet ( uint8_t* source_buffer, uint8_t* destination_buffer, unsigned int max_packet_length )
{
return pktanon::PktAnon::transform_packet(source_buffer, destination_buffer, max_packet_length);
}
int PKTANON__get_erroneus_packet_length ( const int packet_length )
{
return pktanon::GET_LENGTH_VALUE(packet_length);
}
const char* PKTANON__get_error_string ( const int packet_length )
{
return pktanon::GET_ERROR_STRING(packet_length);
}
pktanon-master/src/ 0000755 0000000 0000000 00000000000 12701423271 013305 5 ustar root root pktanon-master/src/LibpcapOutputSource.h 0000644 0000000 0000000 00000001275 12701423271 017437 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_LIBPCAPOUTPUTSOURCE_H
#define PKTANON_LIBPCAPOUTPUTSOURCE_H
#include
#include
namespace pktanon
{
class LibpcapOutputSource
{
public:
~LibpcapOutputSource();
LibpcapOutputSource () {};
virtual int write_packet (const struct pcap_pkthdr* pkt_header, const u_char* packet) = 0;
};
inline LibpcapOutputSource::~LibpcapOutputSource() = default;
}
#endif // PKTANON_LIBPCAPOUTPUTSOURCE_H
pktanon-master/src/chronometer.h 0000644 0000000 0000000 00000002444 12701423271 016007 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
# ifndef PKTANON_CHRONOMETER
# define PKTANON_CHRONOMETER
# include
namespace pktanon
{
class chronometer
{
public:
chronometer() :
start (std::chrono::system_clock::now())
{ }
void reset ()
{
start = std::chrono::system_clock::now();
}
void lap_ns () const
{
std::chrono::duration elapsed_time = std::chrono::system_clock::now() - start;
_plg_info("elapsed time(ns): " << std::chrono::duration_cast(elapsed_time).count() );
}
void lap_ms () const
{
std::chrono::duration elapsed_time = std::chrono::system_clock::now() - start;
_plg_info("elapsed time(mus): " << std::chrono::duration_cast(elapsed_time).count() );
}
size_t get_us() const
{
std::chrono::duration elapsed_time = std::chrono::system_clock::now() - start;
return std::chrono::duration_cast(elapsed_time).count();
}
private:
std::chrono::time_point start;
};
}
# endif
pktanon-master/src/SocketOutput.h 0000644 0000000 0000000 00000001315 12701423271 016127 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_SOCKETOUTPUT_H
#define PKTANON_SOCKETOUTPUT_H
#include "OutputSource.h"
namespace pktanon
{
class SocketOutput : public OutputSource
{
public:
virtual ~SocketOutput();
SocketOutput();
virtual void write_file_header ( PCAP_FILE_HEADER* file_header );
virtual int write_packet ( PCAP_REC_HEADER* record_header, uint8_t* transformed_packet_buffer );
private:
int socket_descriptor;
};
}
#endif // PKTANON_SOCKETOUTPUT_H
pktanon-master/src/OutputSource.h 0000644 0000000 0000000 00000001414 12701423271 016137 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_OUTPUTSOURCE_H
#define PKTANON_OUTPUTSOURCE_H
#include
namespace pktanon
{
struct PCAP_FILE_HEADER;
struct PCAP_REC_HEADER;
class OutputSource
{
public:
virtual ~OutputSource();
OutputSource () {};
virtual void write_file_header(PCAP_FILE_HEADER* file_header) noexcept(false) = 0;
virtual int write_packet ( PCAP_REC_HEADER* record_header, uint8_t* transformed_packet_buffer) = 0;
protected:
};
inline OutputSource::~OutputSource() = default;
}
#endif // INPUTSOURCE_H
pktanon-master/src/console_utils.cpp 0000644 0000000 0000000 00000022426 12701423271 016701 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "console_utils.h"
#include
#include "log.h"
#include "debug.h"
#include "globals.h"
#include "RuntimeConfig.h"
namespace pktanon
{
static const char* default_config_file = "profile.xml";
static struct ::option long_options[] =
{
// config
{"config", required_argument, 0, 'c'},
// input
{"snaplen", required_argument, 0, 's'},
{"interface", required_argument, 0, 'i'},
{"no-promiscuous-mode", no_argument, 0, 'p'},
{"pcap-filter", required_argument, 0, 'e'},
{"use-raw-sockets", no_argument, 0, 'r'},
// output
{"packet-buffered", no_argument, 0, 'U'},
{"socket", required_argument, 0, 'o'},
{"use-ipv6", no_argument, 0, '6'},
{"use-udp", no_argument, 0, 'u'},
{"network", required_argument, 0, 'n'},
// threads
{"threads", optional_argument, 0, 't'},
{"separate-input", no_argument, 0, 'x'},
{"separate-output", no_argument, 0, 'y'},
// miscellaneous
{"use-libpcap", no_argument, 0, 'l'},
// help
{"help", no_argument, 0, 'h'},
{"usage", no_argument, 0, 'h'},
{"quiet", no_argument, 0, 'q'},
{"verbose", no_argument, 0, 'v'}
};
static const char* short_options = "c:s:i:pe:rUo:n:s:6ut::xylhqv";
int get_console_opts ( int argc, char* argv[] )
{
// options values
std::string config_file = default_config_file;
// input
int snaplen = -1;
std::string interface;
bool promiscuous = true;
std::string pcap_filter;
bool use_raw_sockets = false;
// output
bool packet_buffered = false;
std::string sockaddr_port;
bool use_ipv6 = false;
bool use_udp = false;
std::string output_interface;
// threads
int threads = -1;
bool separate_input = false;
bool separate_output = false;
// misc
bool use_libpcap_for_file_io = false;
// getoptlong -------------------------------------------------------------------------------
int opt;
while ( 1 )
{
int option_index = 0;
opt = ::getopt_long ( argc, argv, short_options, long_options, &option_index );
if ( opt==-1 ) break;
switch ( opt )
{
case 'c':
config_file = optarg;
break;
// input
case 's':
snaplen = std::atoi ( optarg );
// if optarg is not a digit string or snaplen is negative
if ( snaplen <= 0 )
{
print_error_message ( "invalid value for \"snaplen\", must be a positive number" );
return -1;
}
break;
case 'i':
interface += optarg;
break;
case 'p':
promiscuous = false;
break;
case 'e':
pcap_filter += optarg;
break;
case 'r':
use_raw_sockets = true;
break;
// output
case 'U':
packet_buffered = true;
break;
case 'o':
sockaddr_port += optarg;
break;
case '6':
use_ipv6 = true;
break;
case 'u':
use_udp = true;
break;
case 'n':
output_interface += optarg;
// threads ------------------------------------------------
// case 't':
// if ( optarg == 0 )
// {
// threads = 0;
// }
// else
// {
// threads = std::atoi ( optarg );
// }
// break;
// case 'x':
// separate_input = true;
// break;
// case 'y':
// separate_output = true;
// break;
// misc ------------------------------------------------
case 'l':
use_libpcap_for_file_io = true;
break;
// help ------------------------------------------------
case 'h':
print_usage();
return 0;
break;
case 'q':
_plg_quiet = true;
break;
case 'v':
_plg_verbose = true;
break;
case '?':
// TRACE("? is returned");
return -1;
break;
default:
std::cerr << "option " << opt << " is not yet implemented" << std::endl;
return -1;
}
}
// last two parameters -------------------------------------------------------------------------------
std::string infile;
std::string outfile;
// TRACE ( optind );
// TRACE ( argc );
// for ( int j = optind; j < argc ; j++ )
// {
// TRACE ( argv[j] );
// }
if ( optind < argc )
{
infile += argv[optind++];
if ( optind < argc )
{
outfile += argv[optind++];
if ( optind < argc )
{
print_error_message ( "too many file names at the end" );
return -1;
}
}
}
// create pktanon-runtime config -------------------------------------------------------------------------------
RuntimeConfig* cfg = const_cast ( &runtime_config );
cfg->setAnonProfile ( std::move ( config_file ) );
// input:
if ( interface.length() == 0 ) // input is files
{
if ( infile.length() == 0 )
{
print_error_message ( "no input file given" );
}
cfg->addInputFileConfig ( infile, use_libpcap_for_file_io );
}
else
{
cfg->addInputInterfaceConfig ( interface, promiscuous, !use_raw_sockets, pcap_filter );
outfile = infile;
}
// TODO check that not all three variants are given
// output:
// check if socket is given:
if ( sockaddr_port.length() != 0 )
{
// parse addr and port
auto colon_pos = sockaddr_port.rfind ( ':' );
if ( colon_pos == std::string::npos )
{
print_error_message ( "no addr/port given, please specify addr:port" );
return -1;
}
std::string sockaddr = sockaddr_port.substr ( 0,colon_pos );
std::string sockport_str = sockaddr_port.substr ( colon_pos+1 );
uint16_t sockport = std::stoul ( sockport_str );
// TRACEV ( sockaddr );
// TRACEV ( sockport_str );
// TRACEV ( sockport );
cfg->addOutputSockConfig ( sockaddr, sockport, use_ipv6, use_udp );
}
else if ( output_interface.length() != 0 )
{
cfg->addOutputNetworConfig ( output_interface );
}
else if ( outfile.length() == 0 )
{
print_error_message ( "no output file given" );
return -1;
}
else
{
// TRACEV ( use_libpcap_for_file_io );
cfg->addOutputFileConfig ( outfile, packet_buffered, use_libpcap_for_file_io );
}
if ( threads >= 0 )
{
cfg->addThreadConfig ( threads, separate_input, separate_output );
}
return 1;
}
void print_error_message ( const char* error )
{
std::cout << "Error: " << error << std::endl;
std::cout << "Use pktanon -h for help" << std::endl;
}
void print_usage()
{
std::cout << "pktanon -- profile-based traffic anonymizer" << std::endl;
std::cout << "Usage: " << std::endl;
std::cout << "\t pktanon [-c profile] input_file output_file" << std::endl;
std::cout << "\t pktanon [options] [input file] [output file]" << std::endl;
std::cout << "" << std::endl;
std::cout << "Configuration:" <\t pktanon anonymization file [default: profile.xml]" <\tread first snaplen bytes from each packet" << std::endl;
std::cout << " \t\t\t\t(for both captures and files) [default:256]" << std::endl;
std::cout << " -i, --interface \tcapture pakcets from interface" << std::endl;
std::cout << "" << std::endl;
std::cout << " if '--interface' option is set:" << std::endl;
std::cout << " -p, --no-promiscuous-mode\tdon't set interface in promiscuous mode" << std::endl;
std::cout << " -e, --pcap-filter \tfilter specification for libpcap" << std::endl;
std::cout << " -r, --use-raw-sockets\tuse linux raw sockets instead of libpcap" << std::endl;
std::cout << " \t(-e option is not available)" << std::endl;
std::cout << "" << std::endl;
std::cout << "Output Parameters:" <\tsend packets to using libpcap-inject" << std::endl;
std::cout << " \t\t\t\t(EXPERIMENTAL)" << std::endl;
std::cout << " -o, --socket \tsend packets to Addr:Port using sockets" << std::endl;
std::cout << " " << std::endl;
std::cout << " if '--socket' option is set:" << std::endl;
std::cout << " -6, --use-ipv6 \t" << std::endl;
std::cout << " -u, --use-udp \t" << std::endl;
std::cout << " " << std::endl;
// std::cout << "Multithreaded Version (EXPERIMENTAL):" << std::endl;
// std::cout << " *-t, --threads []\tstart multithreaded version with threads." << std::endl;
// std::cout << " \t\t\t\tif no argument is given, hardware concurrency is used" << std::endl;
// std::cout << " *-x, --separate-input\t\tseparate input thread" << std::endl;
// std::cout << " *-y, --separate-output\tseparate output thread" << std::endl;
// std::cout << " " << std::endl;
std::cout << "Miscellaneous:" << std::endl;
std::cout << " -l, --use-libpcap\t use libpcap for file i/o" << std::endl;
std::cout << " -h, --help, --usage\t print this message and exit" << std::endl;
std::cout << " -q, --quiet" << std::endl;
std::cout << " -v, --verbose" << std::endl;
std::cout << "" << std::endl;
}
}
pktanon-master/src/includes.h 0000644 0000000 0000000 00000000152 12701423271 015262 0 ustar root root #include
#include
#include
#include
#include pktanon-master/src/RuntimeFactory.h 0000644 0000000 0000000 00000001101 12701423271 016422 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#ifndef PKTANON_IOFACTORY_H
#define PKTANON_IOFACTORY_H
namespace pktanon
{
class Stats;
class RecordsHandler;
class OutputSource;
class RuntimeFactory
{
public:
static RecordsHandler* createRecordsHandler(Stats& stats);
static OutputSource* createOutputSource();
};
}
#endif // PKTANON_IOFACTORY_H
pktanon-master/src/IstreamRecordsHandler.cpp 0000644 0000000 0000000 00000007037 12701423271 020244 0 ustar root root /**
* Copyright (c) 2014, Institute of Telematics, Karlsruhe Institute of Technology.
*
* This file is part of the PktAnon project. PktAnon is distributed under 2-clause BSD licence.
* See LICENSE file found in the top-level directory of this distribution.
*/
#include "IstreamRecordsHandler.h"
#include "RuntimeFactory.h"
#include
#include
#include
#include
#include "PcapUtils.h"
#include "OutputSource.h"
#include "Utils.h"
#include