// Send syns to the given ip address, using the destination ports provided.
void send_syns(const NetworkInterface &iface, IPv4Address dest_ip, const vector<string> &ips) {
// Retrieve the addresses.
NetworkInterface::Info info = iface.addresses();
PacketSender sender;
// Allocate the IP PDU
IP ip = IP(dest_ip, info.ip_addr) / TCP();
// Get the reference to the TCP PDU
TCP &tcp = ip.rfind_pdu<TCP>();
// Set the SYN flag on.
tcp.set_flag(TCP::SYN, 1);
// Just some random port.
tcp.sport(1337);
cout << "Sending SYNs..." << endl;
for(vector<string>::const_iterator it = ips.begin(); it != ips.end(); ++it) {
// Set the new port and send the packet!
tcp.dport(atoi(it->c_str()));
sender.send(ip);
}
// Wait 1 second.
sleep(1);
/* Special packet to indicate that we're done. This will be sniffed
* by our function, which will in turn return false.
*/
tcp.set_flag(TCP::RST, 1);
// Pretend we're the scanned host...
ip.src_addr(dest_ip);
// We use an ethernet pdu, otherwise the kernel will drop it.
EthernetII eth = EthernetII(info.hw_addr, info.hw_addr) / ip;
sender.send(eth, iface);
}
IPv4Reassembler::packet_status IPv4Reassembler::process(PDU &pdu) {
IP *ip = pdu.find_pdu<IP>();
if(ip && ip->inner_pdu()) {
// There's fragmentation
if(ip->is_fragmented()) {
// Create it or look it up, it's the same
Internals::IPv4Stream &stream = streams[make_key(ip)];
stream.add_fragment(ip);
if(stream.is_complete()) {
PDU *pdu = stream.allocate_pdu();
// The packet is corrupt
if(!pdu) {
streams.erase(make_key(ip));
return FRAGMENTED;
}
ip->inner_pdu(pdu);
ip->frag_off(0);
return REASSEMBLED;
}
else
return FRAGMENTED;
}
}
return NOT_FRAGMENTED;
}
void send_packets(PacketSender& sender) {
// ICMPs are icmp-requests by default
IP ip = IP(addr, iface.addresses().ip_addr) / ICMP();
ICMP& icmp = ip.rfind_pdu<ICMP>();
icmp.sequence(sequence);
// We'll find at most 20 hops.
for (auto i = 1; i <= 20; ++i) {
// Set this ICMP id
icmp.id(i);
// Set the time-to-live option
ip.ttl(i);
// Critical section
{
lock_guard<mutex> _(lock);
ttls[i] = i;
}
sender.send(ip);
// Give it a little time
sleep_for(milliseconds(100));
}
running = false;
sender.send(ip);
}
const char *get_host(void *p)
{
IP *ip = (IP*)p;
if (ip && ip->host())
return ip->host();
return "";
}
unsigned long get_ip(void *p)
{
IP *ip = (IP*)p;
if (ip)
return ip->ip();
return 0;
}
unsigned long get_ip(Data &p)
{
IP *ip = (IP*)p.ptr;
if (ip)
return ip->ip();
return 0;
}
const char *get_host(Data &p)
{
IP *ip = (IP*)p.ptr;
if (ip && ip->host())
return ip->host();
return "";
}
TEST_F(IPTest, SecOption) {
IP ip;
ip.security(IP::security_type(0x746a, 26539, 0x77ab, 0x68656c));
IP::security_type found = ip.security();
EXPECT_EQ(found.security, 0x746a);
EXPECT_EQ(found.compartments, 26539);
EXPECT_EQ(found.handling_restrictions, 0x77ab);
EXPECT_EQ(found.transmission_control, 0x68656cU);
}
CostFunction4GoodC(const IP& interpol) :
interpol_(interpol) {
//must be formed only once!
Chained_.resize(interpol.getNumOfPoints(),
interpol.getOutDim() + interpol.getNumOfPoints());
concatenate(Chained_, interpol.getData(),
identity_full<BoostMatrixType> (interpol.getNumOfPoints()));
//now Chained_ = [F|I]
}
TEST_F(IPTest, SSRROption) {
IP ip;
IP::ssrr_type ssrr(0x2d);
ssrr.routes.push_back("192.168.2.3");
ssrr.routes.push_back("192.168.5.1");
ip.ssrr(ssrr);
IP::ssrr_type found = ip.ssrr();
EXPECT_EQ(found.pointer, ssrr.pointer);
EXPECT_EQ(found.routes, ssrr.routes);
}
TEST_F(IPTest, LSRROption) {
IP ip;
IP::lsrr_type lsrr(0x2d);
lsrr.routes.push_back("192.168.2.3");
lsrr.routes.push_back("192.168.5.1");
ip.lsrr(lsrr);
IP::lsrr_type found = ip.lsrr();
EXPECT_EQ(found.pointer, lsrr.pointer);
EXPECT_EQ(found.routes, lsrr.routes);
}
TEST_F(IPTest, AddOption) {
IP ip;
const uint8_t data[] = { 0x15, 0x17, 0x94, 0x66, 0xff };
IP::option_identifier id(IP::SEC, IP::CONTROL, 1);
ip.add_option(IP::option(id, data, data + sizeof(data)));
const IP::option *opt;
ASSERT_TRUE((opt = ip.search_option(id)));
ASSERT_EQ(opt->data_size(), sizeof(data));
EXPECT_TRUE(memcmp(opt->data_ptr(), data, sizeof(data)) == 0);
}
TEST_F(IPTest, RecordRouteOption) {
IP ip;
IP::record_route_type record_route(0x2d);
record_route.routes.push_back("192.168.2.3");
record_route.routes.push_back("192.168.5.1");
ip.record_route(record_route);
IP::record_route_type found = ip.record_route();
EXPECT_EQ(found.pointer, record_route.pointer);
EXPECT_EQ(found.routes, record_route.routes);
}
inline std::size_t hash_value(const IP& ip)
{
size_t seed = 0;
switch (ip.family()) {
case AF_INET:
boost::hash_combine(seed, htonl(ip.in().get().s_addr));
return seed;
default:
UNREACHABLE();
}
}
TEST_F(IPTest, StackedProtocols) {
IP ip = IP() / TCP();
IP::serialization_type buffer = ip.serialize();
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<TCP>());
ip = IP() / UDP();
buffer = ip.serialize();
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<UDP>());
ip = IP() / ICMP();
buffer = ip.serialize();
EXPECT_TRUE(IP(&buffer[0], buffer.size()).find_pdu<ICMP>());
}
void resolveMachineName()
{
try
{
ip.setIp("210.150.25.37");
CPPUNIT_ASSERT_MESSAGE(ip.getHostname(),
ip.getHostname() ==
"www.goo.ne.jp");
}
catch (std::exception& e)
{
CPPUNIT_FAIL(e.what());
}
}
TEST_F(PDUTest, OperatorConcat) {
std::string raw_payload = "Test";
IP ip = IP("192.168.0.1") / TCP(22, 52) / RawPDU(raw_payload);
EXPECT_EQ(ip.dst_addr(), "192.168.0.1");
ASSERT_TRUE(ip.inner_pdu() != NULL);
TCP *tcp = ip.find_pdu<TCP>();
ASSERT_TRUE(tcp != NULL);
EXPECT_EQ(tcp->dport(), 22);
EXPECT_EQ(tcp->sport(), 52);
ASSERT_TRUE(tcp->inner_pdu() != NULL);
RawPDU *raw = tcp->find_pdu<RawPDU>();
ASSERT_TRUE(raw != NULL);
ASSERT_EQ(raw->payload_size(), raw_payload.size());
EXPECT_TRUE(std::equal(raw_payload.begin(), raw_payload.end(), raw->payload().begin()));
}
bool callback(const PDU &pdu)
{
// The packet probably looks like this:
//
// EthernetII / IP / UDP / RawPDU
//
// So we retrieve each layer, and construct a
// DNS PDU from the RawPDU layer contents.
EthernetII eth = pdu.rfind_pdu<EthernetII>();
IP ip = eth.rfind_pdu<IP>();
UDP udp = ip.rfind_pdu<UDP>();
DNS dns = udp.rfind_pdu<RawPDU>().to<DNS>();
// Is it a DNS query?
if(dns.type() == DNS::QUERY) {
// Let's see if there's any query for an "A" record.
for(const auto &query : dns.queries()) {
if(query.type() == DNS::A) {
// Here's one! Let's add an answer.
dns.add_answer(
DNS::Resource(
query.dname(),
"127.0.0.1",
DNS::A,
query.query_class(),
// 777 is just a random TTL
777
)
);
}
}
// Have we added some answers?
if(dns.answers_count() > 0) {
// It's a response now
dns.type(DNS::RESPONSE);
// Recursion is available(just in case)
dns.recursion_available(1);
// Build our packet
auto pkt = EthernetII(eth.src_addr(), eth.dst_addr()) /
IP(ip.src_addr(), ip.dst_addr()) /
UDP(udp.sport(), udp.dport()) /
dns;
// Send it!
sender.send(pkt);
}
}
return true;
}
char IP::calculateClass(IP p) {
int tal;
string adress;
adress = p.getIP().substr(0, p.getIP().find(".")); //tar ut sträng mellan position 0 och första punkten. 192.168.1.1 -> 192
tal = atoi(adress.c_str());
if (tal < 128)
return 'A';
else if (tal >= 128 && tal < 192)
return 'B';
else if (tal >= 192 && tal < 224)
return 'C';
else
return 'X';
}
static bool should_intercept(const IP& ip, const RR* rr, AITF_packet *aitf) {
if (!hosts.isEnabledHost(ip.dst_addr())) return false;
const UDP *udp = ip.find_pdu<UDP>();
if (udp != 0) {
if (udp->dport() == 11467) {
const RawPDU *raw = udp->find_pdu<RawPDU>();
*aitf = AITF_packet(&raw->payload()[0], raw->payload().size());
return true;
}
return false;
}
if (rr != 0) {
try {
UDP udp(&rr->payload()[0], rr->payload().size());
if (udp.dport() == 11467) {
const RawPDU *raw = udp.find_pdu<RawPDU>();
*aitf = AITF_packet(&raw->payload()[0], raw->payload().size());
return true;
}
} catch (malformed_packet e) { }
}
return false;
}
LRESULT CAddressBar::OnLButtonUp(WPARAM wParam, LPARAM lParam)
{
POINTS* p = (POINTS*)(&lParam);
POINT point;
point.x = p->x;
point.y = p->y;
CVSpace2 * Space = Hit(point);
if(Space){
int64 ID = Space->m_Alias;
if(ID == CM_CONNECT && m_SpaceFocused==Space){
::ReleaseCapture();
if (Space->m_State & SPACE_DISABLE)
{
return 0;
}
Space->m_State = SPACE_DISABLE;
m_AddressEdit.SetReadOnly(TRUE);
tstring ipstr = m_AddressEdit.GetEditText(false);
AnsiString ipstr2 = WStoUTF8(ipstr);
IP ip;
ip.Set(ipstr2);
SendParentMessage(CM_CONNECT,ID,ip.GetUint32(),Space);
}else if (ID == CM_DISCONNECT)
{
SendParentMessage(CM_DISCONNECT,ID,0,Space);
}
};
//如果鼠标在bnt之外放开则取消的状态
Space = m_ChildList.front();
if(Space->m_State & SPACE_SELECTED){
::ReleaseCapture();
Space->m_State = 0;
}
Invalidate();
return 0;
}
IP Address::ip(IP ip) {
if(inet_aton(ip.c_str(), &this->sin_addr) == 0) {
std::stringstream error;
error << "[ip] with [ip = "<< ip <<"] invalid ip address provided";
throw SocketException(error.str());
}
return this->ip();
}
packetDecoder::packetDecoder()
{
//ctor
// add protocols to RegProtocol
RegProtocol.clear();
Ethernet *ethIns = new Ethernet();
RegProtocol[ethIns->getProtoId()] = ethIns;
IP *ipIns = new IP();
RegProtocol[ipIns->getProtoId()] = ipIns;
Udp *udpIns = new Udp();
RegProtocol[udpIns->getProtoId()] = udpIns;
TCP *tcpIns = new TCP();
RegProtocol[tcpIns->getProtoId()] = tcpIns;
}
bool sniff_callback(PDU &pdu) {
const IP &ip = pdu.rfind_pdu<IP>();
ttl_map::const_iterator iter;
// Fetch the IP PDU attached to the ICMP response
const IP inner_ip = pdu.rfind_pdu<RawPDU>().to<IP>();
// Critical section
{
std::lock_guard<std::mutex> _(lock);
iter = ttls.find(inner_ip.id());
}
// It's an actual response
if(iter != ttls.end()) {
// Store it
results[inner_ip.id()] = ip.src_addr();
}
return running;
}
void run()
{
// Test IP construction
IP fromString("192.168.0.1");
if (fromString.getOctet(0) != 192
|| fromString.getOctet(1) != 168
|| fromString.getOctet(2) != 0
|| fromString.getOctet(3) != 1)
throw TestFailedException("An IP could not be properly constructed from a string.");
// Test provided octet construction
IP fromOctets(192, 168, 0, 1);
if (fromOctets.getOctet(0) != 192
|| fromOctets.getOctet(1) != 168
|| fromOctets.getOctet(2) != 0
|| fromOctets.getOctet(3) != 1)
throw TestFailedException("An IP could not be properly constructed from octets.");
// Test string representation
if (strcmp("192.168.0.1", fromOctets.getAsString().c_str()) != 0)
throw TestFailedException("An IP's string representation was incorrect.");
// Test inequality
if (fromString != fromOctets)
throw TestFailedException("Inequality operator failed");
// Test equality
IP different = (std::string) "127.0.0.1";
if (different.getOctet(0) != 127 || different.getOctet(1) != 0
|| different.getOctet(2) != 0 || different.getOctet(3) != 1)
throw TestFailedException("An IP could not be constructed from a string.");
if (fromOctets == different)
throw TestFailedException("Equality operator failed");
// Test assignment from string
different = "74.125.113.99";
if (different.getOctet(0) != 74
|| different.getOctet(1) != 125
|| different.getOctet(2) != 113
|| different.getOctet(3) != 99)
throw TestFailedException("An IP could not be assigned from a string.");
// Test binary representation
unsigned int binRep = (208 << 24) + (47 << 16) + (17 << 8) + 18;
IP fromBin(binRep, IP::BO_HOST);
if (binRep != fromBin.getAsBinary(IP::BO_HOST))
throw TestFailedException("An IP's binary representation was incorrect.");
}
void IPResolver::start_resolve()
{
if (resolver && resolver->isWorking()) return;
if (queue.empty())
return;
IP *ip = *queue.begin();
m_addr = ip->ip();
struct in_addr inaddr;
inaddr.s_addr = m_addr;
log(L_DEBUG, "start resolve %s", inet_ntoa(inaddr));
#if COMPAT_QT_VERSION >= 0x030000
if (resolver)
delete resolver;
resolver = new QDns(QHostAddress(htonl(m_addr)), QDns::Ptr);
connect(resolver, SIGNAL(resultsReady()), this, SLOT(resolve_ready()));
#else
resolver->setLabel(QHostAddress(htonl(m_addr)));
#endif
}
IPv4Reassembler::PacketStatus IPv4Reassembler::process(PDU& pdu) {
IP* ip = pdu.find_pdu<IP>();
if (ip && ip->inner_pdu()) {
// There's fragmentation
if (ip->is_fragmented()) {
key_type key = make_key(ip);
// Create it or look it up, it's the same
Internals::IPv4Stream& stream = streams_[key];
stream.add_fragment(ip);
if (stream.is_complete()) {
PDU* pdu = stream.allocate_pdu();
// Use all field values from the first fragment
*ip = stream.first_fragment();
// Erase this stream, since it's already assembled
streams_.erase(key);
// The packet is corrupt
if (!pdu) {
return FRAGMENTED;
}
ip->inner_pdu(pdu);
ip->fragment_offset(0);
ip->flags(static_cast<IP::Flags>(0));
return REASSEMBLED;
}
else {
return FRAGMENTED;
}
}
}
return NOT_FRAGMENTED;
}
TEST_F(IPTest, DefaultConstructor) {
IP ip;
EXPECT_EQ(ip.dst_addr(), "0.0.0.0");
EXPECT_EQ(ip.src_addr(), "0.0.0.0");
EXPECT_EQ(ip.version(), 4);
EXPECT_EQ(ip.id(), 1);
EXPECT_EQ(ip.pdu_type(), PDU::IP);
}
// TODO(evelinad): Move this to Address.
inline struct sockaddr_storage createSockaddrStorage(const IP& ip, int port)
{
struct sockaddr_storage storage;
memset(&storage, 0, sizeof(storage));
switch (ip.family()) {
case AF_INET: {
struct sockaddr_in addr;
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr = ip.in().get();
addr.sin_port = htons(port);
memcpy(&storage, &addr, sizeof(addr));
break;
}
default: {
ABORT("Unsupported family type: " + stringify(ip.family()));
}
}
return storage;
}
void send_packets(PacketSender &sender) {
// ICMPs are icmp-requests by default
IP ip = IP(addr, iface.addresses().ip_addr) / ICMP();
// We'll find at most 10 hops.
for(auto i = 1; i <= 10; ++i) {
// Set this "unique" id
ip.id(i);
// Set the time-to-live option
ip.ttl(i);
// Critical section
{
std::lock_guard<std::mutex> _(lock);
ttls[i] = i;
}
sender.send(ip);
// Give him a little time
std::this_thread::sleep_for(std::chrono::milliseconds(100));
}
running = false;
sender.send(ip);
}
