C:/work/RevealedSystems/EyeSpy-RS/eyespy/src/objects/logic/entity/networkEntity.py

Go to the documentation of this file.

# Copyright (C) 2008-2009  Mark Hanegraaff
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.



import time
from objects.logic.common.logger import logger

## An entity is a simple object containing various properties of an Endpoint or Peer (both terms)
# are used throughout the documentation.
class networkEntity():
    def __init__(self, selfIPAddress, decodedPacketDict, geoIPDatabase, xportTableDict):
        # all sorts of ill shit
        self.selfIPAddress = selfIPAddress
        
        
        if decodedPacketDict['sourceIP'] == self.selfIPAddress:
            self.foreignIPAddress = decodedPacketDict['destIP']
            self.foreignPort      = decodedPacketDict['destPort']
            self.selfPort         = decodedPacketDict['sourcePort']            
        else:
            self.foreignIPAddress = decodedPacketDict['sourceIP']
            
            self.foreignPort      = decodedPacketDict['sourcePort']
            self.selfPort         = decodedPacketDict['destPort']
        
        self.since                = time.time()
        self.lastUpdateTS         = time.time()
        self.totalBytes           = 0
        self.procID               = ""
        self.procName             = ""
        
        self.foreignLongitude     = 0.0
        self.foreignLatitude      = 0.0        
        self.foreignCity          = ""
        self.foreignStateProv     = ""
        self.foreignCountry       = ""
        self.foreignOrganization  = ""
        self.foreignISP           = ""
        
        self.Pid                  = "0"        
        self.processName          = "Unknown";
        
        self.resolveGeoData(geoIPDatabase)        
        
        # now get the PID and Process Name
        nodeInfo, processState = xportTableDict.getXportTableInfo(self.selfPort)
        
        if nodeInfo is not None:
            self.processName = nodeInfo["ProcessName"]
            self.Pid         = "%d" % nodeInfo["Pid"]
            
    
    def __str__(self):
        pass
    
    def __getitem__(self, key):
        
        if hasattr(self, key):
            return getattr(self, key)
        else:
            errString = ":There was an error getting retreiving [%s] key: Attribute does not exist" % (key)
            logger.log(__name__ + errString)
            return ""        
    
    ## Given a reference the Geo IP Database, this function will
    # resolve the Geographical details of itself
    # @param geoIPDatabase database object created by the entityManager class
    def resolveGeoData(self, geoIPDatabase):
        
        geoIPDatabase.find_by_addr(self.foreignIPAddress)
        
        try:
            self.foreignLatitude     = geoIPDatabase.latitude
            self.foreignLongitude    = geoIPDatabase.longitude
            self.foreignCity         = unicode(geoIPDatabase.city)
            self.foreignCountry      = geoIPDatabase.country_name      
            self.foreignOrganization  = unicode(geoIPDatabase.organization)
            self.foreignISP           = unicode(geoIPDatabase.isp)
        except Exception, ex:
            logger.log(__name__ + ": There was an exception extracting GEOIP information")
            logger.log(ex) 
        
        if self.foreignCity == "" or self.foreignCity == None:
            self.exactLocation = False
            self.foreignCity = "Unknown"
            
        else:
            self.exactLocation = True
            
        if self.foreignCountry == "" or self.foreignCountry == None:
            self.foreignCountry = "Unknown"
        
                        
    ## Computed some basic statistics (last update, total bytes)
    # @param decodedPacketDict Decoded Packet Dictionary
    def computeStatistics(self, decodedPacketDict):
        self.lastUpdateTS         = time.time()
        self.totalBytes          += decodedPacketDict['payloadSize']
        
        #print self.foreignIPAddress, " ", self.totalBytes
    
    

---