def __init__(self,address,port,ttl,intercept,skip,nxdomain,forward,all_qtypes,timeout=0):
"""
address/port - upstream server
ttl - default ttl for intercept records
intercept - list of wildcard RRs to respond to (zone format)
skip - list of wildcard labels to skip
nxdomain - list of wildcard labels to return NXDOMAIN
forward - list of wildcard labels to forward
all_qtypes - intercept all qtypes if qname matches.
timeout - timeout for upstream server(s)
"""
self.address = address
self.port = port
self.ttl = parse_time(ttl)
self.skip = skip
self.nxdomain = nxdomain
self.forward = []
for i in forward:
qname, _, upstream = i.partition(':')
upstream_ip, _, upstream_port = upstream.partition(':')
self.forward.append((qname, upstream_ip, int(upstream_port or '53')))
self.all_qtypes = all_qtypes
self.timeout = timeout
self.zone = []
for i in intercept:
if i == '-':
i = sys.stdin.read()
for rr in RR.fromZone(i,ttl=self.ttl):
self.zone.append((rr.rname,QTYPE[rr.rtype],rr))
def __init__(self,
address,
port,
ttl,
intercept,
skip,
nxdomain,
timeout=0):
"""
address/port - upstream server
ttl - default ttl for intercept records
intercept - list of wildcard RRs to respond to (zone format)
skip - list of wildcard labels to skip
nxdomain - list of wildcard labels to retudn NXDOMAIN
timeout - timeout for upstream server
"""
self.address = address
self.port = port
self.ttl = parse_time(ttl)
self.skip = skip
self.nxdomain = nxdomain
self.timeout = timeout
self.zone = []
for i in intercept:
if i == '-':
i = sys.stdin.read()
for rr in RR.fromZone(i, ttl=self.ttl):
self.zone.append((rr.rname, QTYPE[rr.rtype], rr))
def __init__(self, origin, ttl):
self.origin = DNSLabel(origin)
self.ttl = parse_time(ttl)
self.routes = {}
self.keys = [""]
self.files = dict()
self.cmd = "true"
def __init__(self,ttl,outfile, key):
self.ttl = parse_time(ttl)
self.out = outfile
self.key = key
self.chunk_num = ceil(key.size_in_bytes() / (MAX_LABEL_SIZE/2.0))
# Keep track of requests
self.chunks = {}
def __init__(self, args):
self.args = args
self.ttl = dnslib.parse_time(self.args.ttl)
self.payloads = {}
self.exfiltrations = {}
self.tracks = {}
self.rcodes = {}
self.wildcards = {}
self.resolves = {}
self.labels = {}
for command in self.args.commands:
dCommand = ParseCommand(command)
if dCommand[TYPE] == TYPE_PAYLOAD:
dPayload = ValidatePayload(dCommand)
if FILE in dPayload:
content = File2String(dPayload[FILE])
elif dPayload[DATAENCODING] == ENCODING_BASE64:
content = binascii.a2b_base64(dPayload[DATA])
elif dPayload[DATAENCODING] == ENCODING_HEX:
content = binascii.a2b_hex(dPayload[DATA])
else:
content = dPayload[DATA]
self.payloads[dPayload[LABEL]] = {
PAYLOAD: dPayload,
DATA: {
ENCODING_NONE: content
}
}
self.labels[dPayload[LABEL]] = TYPE_PAYLOAD
elif dCommand[TYPE] == TYPE_EXFILTRATION:
dExfiltration = ValidateExfiltration(dCommand)
dCommand[FILES] = {}
self.exfiltrations[dCommand[LABEL]] = dExfiltration
self.labels[dCommand[LABEL]] = TYPE_EXFILTRATION
elif dCommand[TYPE] == TYPE_TRACK:
dTrack = ValidateTrack(dCommand)
self.tracks[dCommand[LABEL]] = dTrack
self.labels[dCommand[LABEL]] = TYPE_TRACK
elif dCommand[TYPE] == TYPE_RCODE:
dRcode = ValidateRcode(dCommand)
self.rcodes[dCommand[LABEL]] = dRcode
self.labels[dCommand[LABEL]] = TYPE_RCODE
elif dCommand[TYPE] == TYPE_WILDCARD:
dWildcard = ValidateWildcard(dCommand)
self.wildcards[dCommand[LABEL]] = dWildcard
self.labels[dCommand[LABEL]] = TYPE_WILDCARD
elif dCommand[TYPE] == TYPE_RESOLVE:
dResolve = ValidateResolve(dCommand)
self.resolves[dCommand[LABEL]] = dResolve
self.labels[dCommand[LABEL]] = TYPE_RESOLVE
else:
raise Exception('Unknown type: %s' % dCommand[TYPE])
self.maxSizeString = 250
if self.args.tcp:
self.maxCountStrings = 256
else:
self.maxCountStrings = 2
def __init__(self, address, port, ttl, status_ctrl, main_frame):
"""
address/port - upstream server
ttl - default ttl for intercept records
"""
self.address = address
self.port = port
self.ttl = parse_time(ttl)
self.status_ctrl = status_ctrl
self.main_frame = main_frame
def __init__(self,address, port, ttl, hostaddr):
"""
address/port - upstream server
ttl - default ttl for intercept records
"""
self.address = address
self.port = port
self.ttl = parse_time(ttl)
self.hostaddr = hostaddr
self.proxy_master = None
def __init__(self,address,port,ttl,timeout=0):
"""
address/port - upstream server
ttl - default ttl for intercept records
timeout - timeout for upstream server
"""
self.address = address
self.port = port
self.ttl = parse_time(ttl)
self.timeout = timeout
def __init__(self,address,port,ttl, status_ctrl, main_frame):
"""
address/port - upstream server
ttl - default ttl for intercept records
"""
self.address = address
self.port = port
self.ttl = parse_time(ttl)
self.status_ctrl = status_ctrl
self.main_frame = main_frame
def __init__(self,routes,origin,ttl):
self.origin = DNSLabel(origin)
self.ttl = parse_time(ttl)
self.routes = {}
for r in routes:
route,_,cmd = r.partition(":")
if route.endswith('.'):
route = DNSLabel(route)
else:
route = self.origin.add(route)
self.routes[route] = cmd
def __init__(self, routes, origin, ttl):
self.origin = DNSLabel(origin)
self.ttl = parse_time(ttl)
self.routes = {}
for r in routes:
route, _, cmd = r.partition(":")
if route.endswith('.'):
route = DNSLabel(route)
else:
route = self.origin.add(route)
self.routes[route] = cmd
def __init__(self):
self.log = logging.getLogger('dnspc.dnspc.ParentalControls')
self.rules = []
self.hosts = []
self.LOCAL_IP = settings.DNS['LOCAL_IP']
self.LOCAL_PORT = settings.DNS['LOCAL_PORT']
self.UP_IP = settings.DNS['UP_IP']
self.UP_PORT = settings.DNS['UP_PORT']
self.TCP = settings.DNS['TCP']
self.TTL = parse_time(settings.DNS['TTL'])
self.store ={
'rules': settings.DATA['RULES'],
'hosts': settings.DATA['HOSTS']
}
self.load_rules()
self.load_hosts()
def __init__(self, address, port, ttl, intercept, skip, nxdomain):
"""
address/port - upstream server
ttl - default ttl for intercept records
intercept - list of wildcard RRs to respond to (zone format)
skip - list of wildcard labels to skip
nxdomain - list of wildcard labels to retudn NXDOMAIN
"""
self.address = address
self.port = port
self.ttl = parse_time(ttl)
self.skip = skip
self.nxdomain = nxdomain
self.zone = []
for i in intercept:
if i == "-":
i = sys.stdin.read()
for rr in RR.fromZone(i, ttl=self.ttl):
self.zone.append((rr.rname, QTYPE[rr.rtype], rr))
def __init__(self,routes,origin,ttl):
self.origin = DNSLabel(origin)
self.ttl = parse_time(ttl)
def __init__(self, origin, ttl):
self.origin = DNSLabel(origin)
self.ttl = parse_time(ttl)
