mirror of
https://github.com/buybitart/get-the-hacker.git
synced 2026-11-18 05:38:51 +00:00
373 lines
22 KiB
Python
373 lines
22 KiB
Python
"""One terminal table. A closed terminal must not stop evidence capture."""
|
|
import json
|
|
import io
|
|
import re
|
|
import os
|
|
import shutil
|
|
import sys
|
|
import textwrap
|
|
import time
|
|
from .assessment import assess
|
|
from .presentation import walk_view, event_rows, GLOSSARY
|
|
|
|
|
|
def clean(value):
|
|
if value is None:return 'N/A'
|
|
if isinstance(value,str):return json.dumps(value,ensure_ascii=True)[1:-1]
|
|
return str(value)
|
|
|
|
|
|
class Console:
|
|
def __init__(self,stream=None,defer=False):
|
|
self.stream=stream;self.defer=defer;self.failed=False;self.last_error=None
|
|
self.states={};self.extra={};self.finished=False;self.probed=False
|
|
self.page='networks';self.selected=0;self.details=False;self.scroll=0
|
|
self.all_networks=False;self.query='';self.searching=False;self.trust_filter='all';self.signs_filter=False
|
|
self.network_provider=None;self.evidence_directory=None
|
|
self._input_state=None;self._key_buffer='';self._escape_at=None;self._proof_cache=None;self.proof_frame=0;self._last_lines=[];self._last_size=None
|
|
self._record={};self._network_page=None;self._page_at=0;self._final=False
|
|
|
|
|
|
def _ansi(self):
|
|
return bool(getattr(self.stream or sys.stdout,'isatty',lambda:False)()) and os.environ.get('TERM','xterm')!='dumb'
|
|
|
|
def _draw(self,rows,red=False):
|
|
if self.failed:return False
|
|
stream=self.stream or sys.stdout
|
|
width=max(20,min(100,shutil.get_terminal_size((80,24)).columns-1))
|
|
left=min(24,max(8,(width-7)//2));right=width-7-left
|
|
border='+'+'-'*(left+2)+'+'+'-'*(right+2)+'+'
|
|
lines=['+'+'-'*(width-2)+'+','|'+ 'GET THE HACKER'.center(width-2)+'|',border]
|
|
for key,value in rows:
|
|
labels=textwrap.wrap(clean(key),width=left,break_long_words=True) or ['']
|
|
values=textwrap.wrap(clean(value),width=right,break_long_words=True) or ['']
|
|
for i in range(max(len(labels),len(values))):
|
|
a=labels[i] if i<len(labels) else '';b=values[i] if i<len(values) else ''
|
|
lines.append('| '+a.ljust(left)+' | '+b.ljust(right)+' |')
|
|
lines.append(border)
|
|
output='\n'.join(lines)+'\n'
|
|
if self._ansi():
|
|
output='\033[2J\033[H'+output
|
|
if red and 'NO_COLOR' not in os.environ:output='\033[31m'+output+'\033[0m'
|
|
try:
|
|
stream.write(output);stream.flush();return True
|
|
except (OSError,UnicodeError) as error:
|
|
self.failed=True;self.last_error=error;return False
|
|
|
|
def emit(self,tag,value,color=None):
|
|
self.extra[tag]=value
|
|
if self.failed:return False
|
|
if self.defer:return True
|
|
return self._draw(list(self.extra.items()),red=color=='31')
|
|
|
|
def state(self,tag,value,color=None):
|
|
self.states[tag]=value
|
|
return self.emit(tag,value,color)
|
|
|
|
def gps(self,fix):
|
|
value=(f"{fix['lat']:.6f}, {fix['lon']:.6f}" if fix.get('status')=='valid' else 'No fix')
|
|
return self.emit('Sensor GPS',value)
|
|
|
|
def network(self,network):
|
|
self.extra.update({'Last network':network.get('ssid') or 'Hidden SSID','BSSID':network.get('bssid'),
|
|
'Channel':network.get('channel'),'RSSI dBm':network.get('rssi')})
|
|
if not self.defer:return self._draw(list(self.extra.items()))
|
|
return True
|
|
|
|
def event(self,alert):
|
|
self.extra.update({'Last event':alert.get('rule_id'),'Source MAC':alert.get('source'),
|
|
'BSSID':alert.get('bssid'),'Channel':alert.get('channel'),'RSSI dBm':alert.get('rssi')})
|
|
if not self.defer:return self._draw(list(self.extra.items()))
|
|
return True
|
|
|
|
def attach(self, session):
|
|
self.network_provider=session.network_page
|
|
self.evidence_directory=session.directory
|
|
|
|
def _start_input(self):
|
|
if self._input_state is not None or self.failed:return
|
|
try:
|
|
output=self.stream or sys.stdout
|
|
if not (sys.stdin.isatty() and output.isatty() and os.isatty(output.fileno())):return
|
|
if os.name=='nt':
|
|
self._input_state=('windows',None)
|
|
else:
|
|
import termios,tty
|
|
fd=sys.stdin.fileno();saved=termios.tcgetattr(fd);tty.setcbreak(fd)
|
|
self._input_state=(fd,saved)
|
|
import codecs
|
|
self._decoder=codecs.getincrementaldecoder('utf-8')(errors='replace')
|
|
import atexit
|
|
atexit.register(self.close)
|
|
except (OSError,ValueError,AttributeError,io.UnsupportedOperation):
|
|
self._input_state=None
|
|
|
|
def close(self):
|
|
state=self._input_state;self._input_state=None
|
|
if state is not None and state[0]!='windows':
|
|
try:
|
|
import termios
|
|
termios.tcsetattr(state[0],termios.TCSANOW,state[1])
|
|
except (OSError,ValueError):pass
|
|
if self._last_lines:
|
|
try:
|
|
stream=self.stream or sys.stdout;stream.write('\x1b[?25h');stream.flush()
|
|
except (OSError,UnicodeError):pass
|
|
|
|
def _poll_input(self):
|
|
if self._input_state is None:return
|
|
if self._input_state[0]=='windows':
|
|
import msvcrt
|
|
for _ in range(32):
|
|
if not msvcrt.kbhit():break
|
|
key=msvcrt.getwch()
|
|
if key in ('\x00','\xe0'):key={'H':'UP','P':'DOWN','K':'LEFT','M':'RIGHT'}.get(msvcrt.getwch(),'')
|
|
self.handle_key(key)
|
|
return
|
|
import select
|
|
fd=self._input_state[0]
|
|
data=self._decoder.decode(os.read(fd,128)) if select.select([fd],[],[],0)[0] else ''
|
|
self.feed_input(data)
|
|
|
|
def feed_input(self, data, now=None):
|
|
stamp=time.monotonic() if now is None else now
|
|
self._key_buffer+=data
|
|
arrows={'\x1b[A':'UP','\x1b[B':'DOWN','\x1b[C':'RIGHT','\x1b[D':'LEFT','\x1b[5~':'PAGEUP','\x1b[6~':'PAGEDOWN'}
|
|
while self._key_buffer:
|
|
if self._key_buffer[0]!='\x1b':
|
|
char=self._key_buffer[0];self._key_buffer=self._key_buffer[1:];self.handle_key(char);self._escape_at=None;continue
|
|
match=next((key for key in arrows if self._key_buffer.startswith(key)),None)
|
|
if match:
|
|
self._key_buffer=self._key_buffer[len(match):];self.handle_key(arrows[match]);self._escape_at=None;continue
|
|
if any(key.startswith(self._key_buffer) for key in arrows):
|
|
if self._escape_at is None:self._escape_at=stamp
|
|
if stamp-self._escape_at<0.1:break
|
|
self._key_buffer=self._key_buffer[1:];self.handle_key('ESC');self._escape_at=None
|
|
|
|
def handle_key(self, key):
|
|
key={'\t':'TAB','\r':'ENTER','\n':'ENTER','\x1b':'ESC','\x7f':'BACKSPACE','\b':'BACKSPACE'}.get(key,key)
|
|
if key in ('\x03','q','Q') and not self.searching:raise KeyboardInterrupt
|
|
if self.searching:
|
|
if key in ('ENTER','ESC'):self.searching=False
|
|
elif key=='BACKSPACE':self.query=self.query[:-1]
|
|
elif len(key)==1 and key.isprintable() and len(self.query)<128:self.query+=key
|
|
self.selected=0;self._page_at=0;return
|
|
pages=('networks','checks','events','help')
|
|
if key in ('1','2','3','4'):
|
|
self.page=pages[int(key)-1];self.selected=0;self.details=False;self.scroll=0;return
|
|
if key in ('TAB','RIGHT','LEFT'):
|
|
self.page=pages[(pages.index(self.page)+(-1 if key=='LEFT' else 1))%4]
|
|
self.selected=0;self.details=False;self.scroll=0;return
|
|
if key=='ESC':self.details=False;self.scroll=0;self.searching=False;return
|
|
if key=='ENTER':self.details=not self.details;self.scroll=0;return
|
|
if self.page=='events' and self.details and key in ('f','b'):
|
|
self.proof_frame=max(0,self.proof_frame+(1 if key=='f' else -1));self.scroll=0;return
|
|
if key in ('PAGEUP','PAGEDOWN'):
|
|
self.scroll=max(0,self.scroll+(5 if key=='PAGEDOWN' else -5));return
|
|
if key in ('UP','DOWN'):
|
|
step=1 if key=='DOWN' else -1
|
|
if self.details:self.scroll=max(0,self.scroll+step)
|
|
else:self.selected=max(0,self.selected+step)
|
|
return
|
|
if self.page=='networks':
|
|
if key in ('a','A'):self.all_networks=not self.all_networks;self.selected=0
|
|
if key=='/':self.searching=True;self.query=''
|
|
if key in ('t','u','x'):
|
|
self.trust_filter={'t':'trusted','u':'unknown','x':'all'}[key];self.selected=0
|
|
if key=='s':self.signs_filter=not self.signs_filter;self.selected=0
|
|
self._page_at=0;self._network_page=None
|
|
if key=='?':self.page='help';self.selected=0;self.details=False
|
|
|
|
def _network_rows(self, record, view):
|
|
if not self.all_networks:return view['nodes'][:3]
|
|
offset=(self.selected//20)*20
|
|
if self.network_provider is not None and (self._network_page is None or time.monotonic()-self._page_at>5 or self._network_page.get('offset')!=offset):
|
|
try:
|
|
self._network_page=self.network_provider(offset=offset,limit=20,search=self.query,trust=self.trust_filter,signs=self.signs_filter)
|
|
self._page_at=time.monotonic()
|
|
except (OSError,ValueError,RuntimeError):self._network_page=None
|
|
from .presentation import network_view
|
|
if self._network_page is not None:
|
|
a=assess(record)
|
|
return [network_view(n,record,a) for n in self._network_page['networks']]
|
|
a=assess(record);rows=[network_view(n,record,a) for n in record.get('networks',[]) if isinstance(n,dict)]
|
|
rows=[n for n in rows if self.query.casefold() in (n['display_name']+' '+str(n.get('bssid'))).casefold() and (self.trust_filter=='all' or (n['trust']=='TRUSTED')==(self.trust_filter=='trusted')) and (not self.signs_filter or n['attack_signs']>0)]
|
|
rows.sort(key=lambda n:-(n.get('last_seen') or 0));return rows[offset:offset+20]
|
|
|
|
def _proof_text(self, event):
|
|
proof=event.get('proof') or {}
|
|
out=['WHAT DATA PROVES IT?',json.dumps(event.get('evidence') or {},ensure_ascii=True),
|
|
'Event: '+str(event.get('id')),'Proof: '+str(proof.get('status') or 'not saved')]
|
|
# Read only the current local Proof file. Never run a pager or shell.
|
|
if self.evidence_directory is not None and re.fullmatch(r'GTH-[0-9]{6,12}',str(event.get('id') or '')):
|
|
from pathlib import Path
|
|
import hashlib
|
|
name='proofs/'+event['id']+'.json';file=Path(self.evidence_directory)/name
|
|
try:
|
|
base=Path(self.evidence_directory).resolve()
|
|
if proof.get('json_path')!=name or file.is_symlink() or file.parent.is_symlink() or file.resolve().parent!=base/'proofs' or file.stat().st_size>8*1024*1024:raise ValueError('Proof path is not valid.')
|
|
signature=(str(file),file.stat().st_mtime_ns,file.stat().st_size,(proof.get('sha256') or {}).get('json'))
|
|
if self._proof_cache is None or self._proof_cache[0]!=signature:
|
|
raw=file.read_bytes()
|
|
if hashlib.sha256(raw).hexdigest()!=signature[-1]:raise ValueError('Proof hash changed.')
|
|
self._proof_cache=(signature,json.loads(raw))
|
|
doc=self._proof_cache[1];frames=doc.get('supporting_events') or []
|
|
self.proof_frame=min(self.proof_frame,max(0,len(frames)-1))
|
|
out+=['Saved rule replay: '+str((doc.get('verification') or {}).get('rule_replay')),
|
|
'Supporting frames: '+str(len(frames))]
|
|
if frames:
|
|
out+=['Frame '+str(self.proof_frame+1)+' / '+str(len(frames))+' / f Next / b Back',json.dumps(frames[self.proof_frame],ensure_ascii=True)[:65536]]
|
|
except (OSError,ValueError,TypeError):out+=['Proof file is not available. Check the saved report.']
|
|
return out
|
|
|
|
def render_screen(self, record, columns=80, height=24, assessment=None, report=None):
|
|
width=max(1,min(120,columns)-1);limit=max(1,min(80,height)-1)
|
|
a=assessment if assessment is not None else assess(record);v=walk_view(record,a)
|
|
def wrap(value):return textwrap.wrap(clean(value),width=width,break_long_words=True,replace_whitespace=False) or ['']
|
|
primary=v['security_result'].replace('_',' ')
|
|
if width<24 or limit<10:
|
|
short=[primary,'GET THE HACKER',v['data_state'],'Small screen. Use Mobile view.']
|
|
return [line[:width] for value in short for line in wrap(value)][:limit]
|
|
header=['GET THE HACKER'.center(width),'Live Wi-Fi Security Walk'.center(width),
|
|
'MONITORING '+v['monitoring'],v['data_state'],
|
|
'Walk Time '+v['walk_time'],
|
|
'Networks Seen '+clean(v['networks_seen'])+' / Attack Signs '+clean(v['attack_signs']),
|
|
'SECURITY RESULT: '+primary,
|
|
'Checks '+str(len(a['rules_checked']))+'/'+str(len(a['rule_results']))+' / NOT ASSESSED '+str(len(a['rules_not_checked']))]
|
|
if v['capture_title'] in ('NO WIFI INTERFACE','CAPTURE NOT AVAILABLE','WIDS NOT AVAILABLE','FRAMES DELAYED','NO FRESH FRAMES','EVIDENCE LIMIT','CAPTURE ERROR'):header.append(v['capture_title'])
|
|
if v['synthetic']:header.insert(3,'SYNTHETIC DEMO')
|
|
body=[]
|
|
if self.page=='networks':
|
|
rows=self._network_rows(record,v)
|
|
if rows:
|
|
self.selected=min(self.selected,(self._network_page.get('filtered',len(rows))-1 if self.all_networks and self._network_page else len(rows)-1))
|
|
else:self.selected=0
|
|
body+=['WI-FI NETWORKS AROUND YOU','GTH SENSOR',' | observed frames']
|
|
if record.get('mode')=='managed':
|
|
link=record.get('network_status') or {}
|
|
body+=['LOCAL WI-FI LINK','SSID: '+clean(link.get('ssid')),'BSSID: '+clean(link.get('bssid')),'Signal: '+clean(link.get('rssi'))+' dBm','No WIDS radio frames were measured.']
|
|
if self.all_networks:body+=['ALL NETWORKS / search: '+self.query,'Trust: '+self.trust_filter+' / Signs: '+str(self.signs_filter)]
|
|
chosen=self.selected%20 if self.all_networks else self.selected
|
|
if self.details and rows:
|
|
n=rows[min(chosen,len(rows)-1)]
|
|
body=['NETWORK DETAILS',n['display_name'],n.get('bssid'),
|
|
'Trust: '+n['trust'],'Channel: '+clean(n.get('channel')),'Signal: '+clean(n.get('rssi'))+' dBm',
|
|
'Last Seen: '+clean(n.get('last_seen')),'Attack Signs: '+str(n['attack_signs']),
|
|
'WHAT DOES THIS MEAN?',n['explanation'],'RSSI is not distance.']
|
|
else:
|
|
for i,n in enumerate(rows):
|
|
mark='>' if i==chosen else ' '
|
|
body+=[mark+' o '+n['display_name'],
|
|
' '+n['trust']+(' / ATTACK SIGNS' if n['attack_signs'] else '')]
|
|
if not rows:body+=['No AP frame was saved.']
|
|
body+=['a VIEW ALL NETWORKS','Enter opens Network Details.']
|
|
elif self.page=='checks':
|
|
rows=v['checks'];self.selected=min(self.selected,max(0,len(rows)-1))
|
|
if self.details and rows:
|
|
r=rows[self.selected]
|
|
body=['ATTACK CHECK: '+r['name'],'WHAT DOES GTH CHECK?',r['condition'],
|
|
'WHAT DID GTH SEE?',r['observed'],'Last checked group: '+json.dumps(r.get('last_window'),ensure_ascii=True),
|
|
'RESULT: '+r['display_state'],r['reason'],'WHAT DATA PROVES IT?',json.dumps(r['evidence_refs'],ensure_ascii=True),
|
|
'WHAT DOES THIS MEAN?',r['help']]
|
|
else:
|
|
body=['ATTACK CHECKS']+[(('> ' if i==self.selected else ' ')+r['name']+' / '+r['display_state']) for i,r in enumerate(rows)]
|
|
elif self.page=='events':
|
|
rows=event_rows(record);self.selected=min(self.selected,max(0,len(rows)-1))
|
|
if self.details and rows:
|
|
e=rows[self.selected];m=next((x for x in a['events'] if x.get('id')==e.get('id')),{})
|
|
body=['SECURITY EVENT','WHAT HAPPENED?',m.get('fact','A rule event was saved.'),
|
|
'WHY DID GTH REPORT IT?',e.get('rule_id'),'BSSID: '+clean(e.get('bssid'))]+self._proof_text(e)+['WHAT SHOULD I DO?',m.get('action','Read the saved Evidence.')]
|
|
else:body=['EVENTS / recent saved rows']+[(('> ' if i==self.selected else ' ')+str(e.get('id'))+' / '+str(e.get('rule_id'))) for i,e in enumerate(rows)]
|
|
if not rows:body+=['No rule event was saved.','This does not prove a safe network.']
|
|
else:
|
|
words=list(GLOSSARY);self.selected=min(self.selected,len(words)-1)
|
|
body=['HELP / ENTER OPENS A TERM']
|
|
if self.details:body+=[words[self.selected],GLOSSARY[words[self.selected]],'Arrow keys scroll. Esc returns.']
|
|
else:body +=[(('> ' if i==self.selected else ' ')+word) for i,word in enumerate(words)]
|
|
if not self.details:body+=['Radio: '+clean(v.get('interface'))+' / CH '+clean(v.get('channel'))]
|
|
if report:body+=['Reports: '+report]
|
|
if self._final and self.extra.get('REPORT'):body+=['Report folder: '+str(self.extra['REPORT'])]
|
|
flat=[line for value in body for line in wrap(value)]
|
|
head=[line for value in header for line in wrap(value)]
|
|
footer=(['Saved session. Open report.html.'] if self._final else
|
|
['1 NETWORKS 2 CHECKS 3 EVENTS 4 HELP','Tab / arrows / Enter / Esc / q Stop'] if self._input_state is not None else
|
|
['Read-only terminal. Use Mobile view.'])
|
|
foot=[line for value in footer for line in wrap(value)]
|
|
space=max(1,limit-len(head)-len(foot)-1)
|
|
if not self.details and self.page in ('checks','events','help'):
|
|
marker=next((i for i,line in enumerate(flat) if line.startswith('> ')),self.selected)
|
|
if marker<self.scroll:self.scroll=marker
|
|
elif marker>=self.scroll+space:self.scroll=marker-space+1
|
|
self.scroll=min(self.scroll,max(0,len(flat)-space))
|
|
visible=flat[self.scroll:self.scroll+space]
|
|
result=head[:limit]+['-'*width]+visible+foot
|
|
return [line[:width] for line in result[:limit]]
|
|
|
|
def _draw_screen(self, lines, size, result):
|
|
if self.failed:return False
|
|
changed=self._last_size!=size or not self._last_lines
|
|
output='\x1b[2J\x1b[H\x1b[?25l' if changed else ''
|
|
for i in range(min(max(1,size[1]-1),len(lines) if changed else max(len(lines),len(self._last_lines)))):
|
|
line=lines[i] if i<len(lines) else ''
|
|
old=self._last_lines[i] if i<len(self._last_lines) else None
|
|
if changed or line!=old:
|
|
color=''
|
|
if 'NO_COLOR' not in os.environ:
|
|
if ('SECURITY RESULT:' in line and result=='DETECTED') or 'ATTACK SIGNS' in line:color='\x1b[31m'
|
|
elif 'SECURITY RESULT:' in line and result=='NOT_DETECTED':color='\x1b[32m'
|
|
elif 'SECURITY RESULT:' in line:color='\x1b[37m'
|
|
output+=f'\x1b[{i+1};1H\x1b[2K'+color+line+('\x1b[0m' if color else '')+'\n'
|
|
try:
|
|
stream=self.stream or sys.stdout;stream.write(output);stream.flush()
|
|
self._last_lines=list(lines);self._last_size=size;return True
|
|
except (OSError,UnicodeError) as error:
|
|
self.failed=True;self.last_error=error;self.close();return False
|
|
|
|
def update(self,record,final=False,report=None):
|
|
if self.failed:return False
|
|
if self.finished:return True
|
|
if not self.probed and not self._ansi():
|
|
self.probed=True
|
|
try:
|
|
(self.stream or sys.stdout).write('')
|
|
except (OSError,UnicodeError) as error:
|
|
self.failed=True;self.last_error=error;return False
|
|
a=assess(record)
|
|
if self._ansi():
|
|
try:
|
|
self._record=record;self._final=final
|
|
self._start_input();self._poll_input()
|
|
size=shutil.get_terminal_size((80,24))
|
|
lines=self.render_screen(record,size.columns,size.lines,a,report)
|
|
result=self._draw_screen(lines,(size.columns,size.lines),a['hacker_activity'])
|
|
self.finished=final
|
|
if final:self.close()
|
|
return result
|
|
except Exception as error:
|
|
# UI faults must not stop Capture. Ctrl+C still reaches the caller.
|
|
self.failed=True;self.last_error=error;self.close();return False
|
|
source=record.get('source') or {};gps=record.get('sensor_gps') or {}
|
|
start=record.get('started_at');end=record.get('ended_at',record.get('updated_at',time.time()))
|
|
seconds=max(0,int(end-start)) if isinstance(start,(int,float)) and isinstance(end,(int,float)) else None
|
|
duration=(f'{seconds//3600:02}:{seconds//60%60:02}:{seconds%60:02}' if seconds is not None else None)
|
|
networks=a['networks'];trusted=sum(n['baseline_state']=='match' for n in networks)
|
|
rows=[('Monitoring', 'STOPPED' if final else 'ACTIVE' if record.get('capture_active') else record.get('status','WAIT')),
|
|
('Interface',source.get('interface')),('Mode',str(record.get('mode','N/A')).upper()),
|
|
('Channel',a['observed_channel']),('Duration',duration),('Frames received',a['frames_received']),
|
|
('Frames analyzed',a['frames_analyzed']),('Frames dropped',a['frames_dropped']),
|
|
('Networks found',a['networks_observed']),('Trusted APs',trusted),('Unknown APs',len(networks)-trusted)]
|
|
rows.extend((r['name'],r['result'].replace('_',' ')) for r in a['rule_results'])
|
|
rows.extend([('HACKER ACTIVITY',a['hacker_activity'].replace('_',' ')),('Capture quality',a['capture_quality']),('Capture state',a['capture_title']),
|
|
('Evidence',a['proof_check_state']),('Monitoring errors',len(record.get('errors') or [])),
|
|
('Sensor GPS',f"{gps.get('lat')}, {gps.get('lon')}" if gps.get('status')=='valid' else 'No fix')])
|
|
for key in ('Last network','BSSID','RSSI dBm','Last event','Source MAC'):
|
|
if key in self.extra:rows.append((key,self.extra[key]))
|
|
if 'ERROR' in self.extra:rows.append(('Error',self.extra['ERROR']))
|
|
if 'WEB' in self.extra:rows.append(('Mobile view',self.extra['WEB']))
|
|
if report:rows.append(('Reports',report))
|
|
if final:rows.append(('Report folder',self.extra.get('REPORT')))
|
|
if self._ansi() or final:
|
|
result=self._draw(rows,red=a['hacker_activity']=='DETECTED')
|
|
else:result=True
|
|
self.finished=final
|
|
return result
|