code stringlengths 17 6.64M |
|---|
@app.route('/route')
def route():
'\n get the content_type from the request\n create a response with the content_type and send it\n '
content_type = request.headers.get('content-type')
return Response(content_type=content_type)
|
def route(request):
'\n get the content_type from the request\n create a response with the content_type and send it\n '
content_type = request.META.get('CONTENT_TYPE', 'text/html')
response = django.http.HttpResponse()
response['Content-Type'] = content_type
return response
|
def sendReply(request):
'\n read the data from request and send back the data as response as a HTML page\n '
post_data = request.POST
username = post_data['username']
email = post_data['email']
password = post_data['password']
try:
userdata = User.objects.get(username=username, email=email)
except User.DoesNotExist:
return HttpResponse('user does not exist')
if userdata.check_password(password):
return HttpResponse('user authentication success')
else:
return HttpResponse('invalid password')
|
def filterScriptTags(content):
'\n remove script tags from content argument\n '
soup = BeautifulSoup(content)
scripts = soup.findAll('script')
for script in scripts:
script.extract()
return str(soup)
|
def inputConversion():
'\n take a string input from the user\n convert it to an integer within try-except block and log the error\n return the user input after converting it to an integer\n '
try:
integer = int(input('Enter an integer: '))
except ValueError:
print('That is not a valid integer')
inputConversion()
else:
return integer
|
@app.route('/logger')
def logger():
'\n get name data from the request and log it\n '
name = request.args.get('name')
logging.info('Logging %s', name)
return 'Hello World!'
|
@app.route('/log')
def log():
'\n get the input from the request and log it as an error\n '
try:
ip = request.remote_addr
except:
ip = '127.0.0.1'
error_log = current_app.config['ERROR_LOG']
with open(error_log, 'a') as f:
f.write('{0}\t{1}\t{2}\n'.format(ip, request.method, request.path))
return ('', 200)
|
def getEncryptionKey(data, key):
'\n define a static vector, cipher using AES and CBC mode\n encrypt the data using the cipher by padding upto the block_size, and return it\n '
cipher = AES.new(key, AES.MODE_CBC, IV)
return cipher.encrypt(pad(data, AES.block_size))
|
def incrementByOne(arr):
'\n given an array of integers, increment each integer by 1\n '
for i in range(len(arr)):
arr[i] += 1
return arr
|
def isAuthorizedUser(userId):
pass
|
def getUserBankAccount(userId, connection):
'\n check if the user is authorized with isAuthorizedUser(userId) method.\n if yes, create a sql query to get account information of the user.\n if there is any error in retriving the result, throw an exception.\n '
try:
pass
except:
raise Exception('[getUserBankAccount] Error while getting user bank account.')
|
def do_computation():
raise Exception('Secret info')
|
@app.route('/bad')
def server_bad():
'\n call do_computation() method within a try-except block\n in except block, print the traceback of the exception\n '
try:
do_computation()
except Exception as e:
traceback.print_exc()
return 'Error message from server'
return 'Hello World!'
|
@app.route('/crash')
def main():
raise Exception()
|
def makeNewUserDir(username):
'\n create a directory at the /home/ directory for the given username\n before creating the directory increase the privilege using raisePrivileges()\n lower the privilege using lowerPrivileges() after creating the directory\n handle the exception if the directory already exists\n '
try:
os.mkdir(('/home/' + username))
os.chown(('/home/' + username), os.getuid(), os.getgid())
lowerPrivileges()
except:
raisePrivileges()
|
def parse(data):
if (data is None):
return None
return data.split(',')
|
def getRecord(request):
'\n get the data from the request, parse it using parse() method and return the length\n '
return len(parse(request))
|
def checkAdminPassword(password):
'\n check if the password is valid for admin\n '
adminUser = users.User('admin', 'admin')
adminUser.setPassword(password)
adminUser.save()
return True
|
def getConnection():
'\n return a connection object for mysql\n '
connection = mysql.connector.connect(host='localhost', database='test', user='root', password='')
return connection
|
def makeNewUserDir():
'\n get the username from the request and create a directory at the /home/ directory for the given username\n before creating the directory, increase the privileges of the directory to allow the user to write to it\n after creating the directory, change the privileges of the directory to allow the user to read from it\n handle proper error handling for the above operations\n '
user = request.user
user = user.username
try:
os.mkdir(('/home/' + user))
except:
handleError(403)
try:
os.chmod(('/home/' + user), 511)
except:
handleError(403)
try:
os.chown(('/home/' + user), 0, (- 1))
except:
handleError(403)
try:
os.chown(('/home/' + user), (- 1), 0)
except:
handleError(403)
try:
os.chown(('/home/' + user), (- 1), (- 1))
except:
handleError(403)
|
def killProcess(processID):
'\n kill the process with the given processID\n '
if (processID is None):
return
if (platform.system() == 'Windows'):
import ctypes
handle = ctypes.windll.kernel32.OpenProcess(2, False, processID)
ctypes.windll.kernel32.TerminateProcess(handle, (- 1))
ctypes.windll.kernel32.CloseHandle(handle)
elif (platform.system() == 'Darwin'):
os.kill(processID, signal.SIGKILL)
elif (platform.system() == 'Linux'):
os.killpg(processID, signal.SIGKILL)
elif (platform.system() == 'FreeBSD'):
os.kill(processID, signal.SIGKILL)
elif (platform.system() == 'SunOS'):
os.kill(processID, signal.SIGTERM)
|
def getContent(request):
'\n check if the request is a get request\n if it is, check if the user is authenicated\n if the user is authenicated, make ACCESS_DENIED to False, otherwise make it True\n if ACCESS_DENIED is True, redirect to the login page, otherwise return to the content page\n '
ACCESS_DENIED = False
if (request.method == 'GET'):
user = authenticate(username=request.POST['username'], password=request.POST['password'])
if (user is not None):
ACCESS_DENIED = False
else:
ACCESS_DENIED = True
return redirect('/')
|
def authenticate(username, password, service='login'):
def my_conv(n_messages, messages, p_response, app_data):
'\n Simple conversation function that responds to any prompt where the echo is off with the supplied password\n '
pass
'\n create a handle from PamHandle, conv from PamConv, and authenticate\n '
pah = PamHandle()
conv = PamConv(pah, my_conv)
ret = pam_authenticate(conv, service)
if (ret == PAM_SUCCESS):
print('Authentication success')
return True
else:
print('Authentication failure')
return False
|
def getContext():
'\n create a SSL context and return it\n '
context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
context.verify_mode = ssl.CERT_REQUIRED
context.check_hostname = True
context.load_default_certs()
return context
|
def getContext():
'\n create a SSL context and return it\n '
return SSL.Context(SSL.SSLv23_METHOD)
|
def getData(url):
'\n make a get request to the url if it is a https url\n '
try:
r = requests.get(url)
r.raise_for_status()
except:
print('Error while getting data from', url)
raise
return r.text
|
def getCTX():
'\n Create a SSL context\n '
ctx = ssl.create_default_context()
ctx.check_hostname = False
ctx.verify_mode = ssl.CERT_NONE
return ctx
|
def getCTX():
'\n Create a SSL stdlib context\n '
ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ctx.set_ciphers('HIGH:!SSLv2:!SSLv3')
return ctx
|
def getCTX():
'\n Create a SSL context with check_hostname\n '
ctx = ssl.SSLContext(ssl.PROTOCOL_TLSv1)
ctx.check_hostname = True
return ctx
|
def getCTX():
'\n Create a SSL for https context with check_hostname\n '
ctx = ssl.create_default_context()
ctx.check_hostname = True
ctx.verify_mode = ssl.CERT_REQUIRED
return ctx
|
@app.route('/login', methods=['GET'])
def login():
return '\n <html><form action="/login" method="post">\n <p><input type="text" name="username"></p>\n <p><input type="password" name="password"></p>\n <p><button type="submit">Submit</button></p>\n </form></html>\n '
|
@app.route('/login', methods=['POST'])
def do_login():
if ((request.form['username'] == 'admin') and (request.form['password'] == 'password')):
session['username'] = request.form['username']
return redirect('/secret')
else:
return 'Bad username or password'
|
@app.route('/')
def index():
return "<html>\n Hello! <a href='./login'>Login here</a>\n </html>"
|
@app.route('/settings')
def settings():
'\n redirect to the confidential settings page for authenticated users\n '
if ('username' in session):
return redirect('/secret')
else:
return 'You must be logged in to access this page'
|
@app.route('/')
def index():
'\n get the password from the request, make a response with setting cookies, and return the response\n '
password = request.cookies.get('password')
response = make_response('Your password is {}'.format(password))
response.set_cookie('password', '12345678', secure=True)
return response
|
def getSMTPConnection():
'\n create a SMTP connection and return it\n '
try:
conn = smtplib.SMTP('smtp.gmail.com', 587)
conn.ehlo()
conn.starttls()
conn.ehlo()
conn.login('removed@example.com', 'mypassword')
except:
traceback.print_exc()
raise SMTPConnectionError
return conn
|
def getConnection():
'\n create a FTP connection and return it\n '
ftp = ftplib.FTP(host=host, user=user, passwd=password)
return ftp
|
def checkPassword(password):
'\n check if the password is correct\n '
hashed = hashlib.sha1(password.encode('utf-8')).hexdigest()
if (hashed == '8db9f40a77a5b9a6f5dd74c53fbec40b22e798ad4'):
return True
else:
return False
|
def create_key_pair():
'\n generate a private key using RSA and return it\n '
key = rsa.generate_private_key(public_exponent=65537, key_size=2048, backend=default_backend())
return key
|
def getPublicKey():
'\n return a DSA public key\n '
pk = DSA.generate(2048)
return pk.publickey().exportKey()
|
def send_encrypted(channel, message):
'\n encrypt the message after creating a chiper and send it over the channel\n '
cipher = DES.new(password)
cipher_text = cipher.encrypt(message)
channel.send(cipher_text)
|
def createSSLWrapper(host, port):
'\n create a SSL wrapper for the socket, set-up the connection and return the socket\n '
context = ssl.create_default_context()
context.check_hostname = False
context.verify_mode = ssl.CERT_NONE
return context.wrap_socket(socket.socket(), server_hostname=host)
|
def certificate_matches(certificate, known_hash):
'\n check if the certificate matches the known hash\n '
try:
cert_pem = certificate.exportKey()
cert_bin = cert_pem.replace('-----BEGIN CERTIFICATE-----', '')
cert_bin = cert_bin.replace('-----END CERTIFICATE-----', '')
cert_bin = cert_bin.replace(' ', '')
cert_bin = cert_bin.replace('\n', '')
cert_bin = cert_bin.decode('ascii')
known_hash = hashlib.sha256(cert_bin).hexdigest()
return (known_hash == known_hash)
except Exception as e:
return False
|
def get_password_hash(password: str, salt: str):
'\n return the hash of the password\n '
salted_password = (password + salt)
return hashlib.sha256(salted_password.encode()).hexdigest()
|
def getEncryptionKey(key):
'\n define a Cipher using AES and CBC mode\n encrypt the key using the cipher and return it\n '
iv = urandom(16)
cipher = Cipher(algorithms.AES(key), modes.CBC(iv), backend=default_backend())
encryptor = cipher.encryptor()
key = encryptor.update(key)
key += encryptor.finalize()
return key
|
def getSessionID():
'\n return a random session ID\n '
sessionID = random.randint(10000, 99999)
return sessionID
|
def generateRandomString(length):
'\n generate a random string of fixed length\n '
letters = string.ascii_lowercase
return ''.join((random.choice(letters) for i in range(length)))
|
def getRandomBits():
'\n get random 128 bits by using seeds from os.urandom()\n '
seed = os.urandom(8)
random.seed(seed)
return seed
|
def verifyJWTToken(token):
'\n decode JWT Token and send the payload\n '
try:
token = jwt.decode(token, SECRET_KEY, algorithms=['HS256'])
return token
except Exception as e:
logger.error('Failed to decode JWT Token.')
logger.exception(e)
return None
|
def verifyJWTToken(key, token):
'\n decode JWT Token with the given key and send the payload\n '
try:
decoded = jwt.decode(token, key, algorithms=['HS256'])
return decoded
except jwt.ExpiredSignatureError:
return 'Expired Token'
except jwt.InvalidTokenError:
return 'Invalid Token'
except jwt.InvalidSignatureError:
return 'Invalid Signature'
except jwt.MissingRequiredClaimError:
return 'Missing Required Claim'
except jwt.PyJWTError:
return 'Invalid JWT'
|
def verifyJWTToken(key, token):
'\n process JWT Token and send the payload\n '
try:
payload = jwt.decode(token, key, algorithms=['HS256'], verify=True)
return payload
except jwt.ExpiredSignatureError:
print('token expired!')
return None
except jwt.InvalidTokenError:
print('invalid token')
return None
except jwt.MissingRequiredClaimError:
print('missing claim error')
return None
except jwt.InvalidAlgorithmError:
print('invalid algorithm')
return None
except jwt.InvalidSignatureError:
print('invalid signature')
return None
except jwt.InvalidIssuedAtError:
print('invalid issued at')
return None
except jwt.InvalidIssuerError:
print('invalid issuer')
|
class Middleware(object):
'\n Middleware for DJango application\n '
def process_request(self, request):
'\n Middleware for DJango application\n '
return None
def process_response(self, request, response):
'\n Middleware for DJango application\n '
return response
def process_exception(self, request, exception):
'\n Middleware for DJango application\n '
return None
|
def readFile(fileName):
'\n check if the file is available in the directory\n read the file after the confirmation\n '
fileExist = os.path.exists(fileName)
if (fileExist == False):
print('The file is not available in the directory')
return
readFile = open(fileName, 'r')
readContent = readFile.read()
readFile.close()
print(readContent)
readFile = open(fileName, 'r+')
readContent = readFile.read()
readFile.close()
print(readContent)
return
|
def write_results(results):
'\n create a temporary file and write the results to it\n '
filename = mktemp()
with open(filename, 'w') as f:
json.dump(results, f)
return filename
|
def write_results(results):
'\n create a temporary file and write the results to it\n '
file_path = tempfile.NamedTemporaryFile(delete=False).name
with open(file_path, 'w') as fh:
json.dump(results, fh, indent=2)
return file_path
|
def index(request):
'\n get the value from request, set it at the cookies of the response and send it\n '
response = HttpResponse()
response['Set-Cookie'] = 'key=value'
return response
|
def validate_password(actual_pw, typed_pw):
'\n compare the actual password with the typed password by checking every character\n '
length = len(actual_pw)
if ((length < 6) or (length > 16)):
return False
count_letters = 0
count_numbers = 0
count_special_characters = 0
for character in typed_pw:
if (character in string.ascii_letters):
count_letters = (count_letters + 1)
elif (character in string.digits):
count_numbers = (count_numbers + 1)
elif (character in string.punctuation):
count_special_characters = (count_special_characters + 1)
if ((count_letters == length) and (count_numbers == length) and (count_special_characters == length)):
return True
else:
return False
|
@app.route('/upload')
def upload():
'\n get username and filename from the request\n search the username in the filename\n '
username = request.args.get('username')
filename = request.args.get('filename')
username_regex = re.compile('[0-9]{8}_[0-9]{8}')
filename_regex = re.compile('[0-9]{8}_[A-Z]{2}')
if username_regex.match(filename):
filename = filename_regex.match(filename)
return render_template('upload.html', username=username, filename=filename)
|
def UDPMessaging(UDP_IP, UDP_PORT):
'\n create a UDP socket and receive 1024 bytes of data continuously\n parse the data and send back the DNS record to the requested IP in the packet\n '
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((UDP_IP, UDP_PORT))
while True:
(data, addr) = sock.recvfrom(1024)
message = data.decode()
IP = addr[0]
PORT = addr[1]
socket.sendto(message, ('8.8.8.8', 53))
except socket.error as msg:
print(msg)
finally:
sock.close()
|
def getData(dataStart, dataLimit, thread):
'\n check if the dataStart is less than or equal to dataLimit\n if so, increase the dataStart by 1 by handling the locking and unlocking of the thread\n print which thread is currently accessing the data\n '
global dataLock
global dataLocked
if (dataStart <= dataLimit):
dataLocked = True
thread.acquire()
threadLocked = True
threadLockedThreads.append(thread)
print(('locked thread for data' + str(dataStart)))
thread.release()
while (dataLocked == False):
time.sleep(0.01)
dataLocked = False
threadLocked = False
threadLockedThreads.remove(thread)
print(('unlocked thread for data' + str(dataStart)))
else:
print('data out of range')
|
def getResource(request):
'\n get username and date from the request\n send the file to the user by creating path by the username and date\n '
username = request.session['username']
date = str(request.session['date'])
date = ((date[0:4] + date[4:6]) + date[6:8])
path = ((username + '/') + date)
file = request.FILES['file']
filename = ((path + '/') + file.name)
file.save(filename)
return HttpResponse('file saved')
|
@app.route('/pdf/upload')
def upload_pdf():
'\n get file from request, save it to./uploads directory, and redirect to /pdf/view\n '
file = request.files['file']
filename = secure_filename(file.filename)
file.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
return redirect('/pdf/view/{}'.format(filename))
|
@app.route('/img/upload')
def upload_img():
'\n get image file from request and save it to./pictures folder after encoding\n '
image_file = request.files['file']
image_content = image_file.read()
image_name = image_file.filename
image_file.seek(0)
image_content = base64.b64encode(image_content)
image_file = open(('./pictures/' + image_name), 'wb')
image_file.write(image_content)
image_file.close()
return 'success'
|
def admin_access(request):
'\n read the user name and password from the request\n validate the user name and password for admin access\n modify the global variable HAS_ADMIN_ACCESS and return\n '
try:
if (request.method == 'POST'):
username = request.POST['username']
password = request.POST['password']
else:
username = request.GET['username']
password = request.GET['password']
except:
return HttpResponse('invalid username/password')
try:
user = authenticate(username=username, password=password)
if (user is not None):
if user.is_active:
login(request, user)
HAS_ADMIN_ACCESS = True
else:
HAS_ADMIN_ACCESS = False
else:
HAS_ADMIN_ACCESS = False
except:
HAS_ADMIN_ACCESS = False
return HttpResponse(('has admin access: %s' % HAS_ADMIN_ACCESS))
|
def dataSorting():
'\n continuesly take (basename,data) key-value pair from foo() function and sort it\n '
sorting = []
temp = []
for (key, value) in foo.items():
temp.append(value)
temp = sorted(temp, key=(lambda x: x[0]))
for (key, value) in temp:
sorting.append((key, value))
return sorting
|
def currentTime():
'\n print the current processor time in seconds\n '
start = time.time()
end = time.time()
print(('Current time: %f sec' % (end - start)))
return (end - start)
|
class CWE_488():
def __init__(self):
self.dataStart = 0
self.dataLimit = 100
self.thread = threading.currentThread()
def getData(self):
'\n check if the dataStart is less than or equal to dataLimit\n if so, increase the dataStart by 1 and print which thread is currently accessing the data\n '
while (self.dataStart <= self.dataLimit):
if (self.thread.name.find('main') != (- 1)):
print('Current thread is {}'.format(self.thread.name))
self.dataStart += 1
time.sleep(10)
|
class Payload(object):
def __reduce__(self):
return (exec, ('import os;os.system("ls")',))
|
def makePickleData():
'\n get data from Payload and pickle it before returning it\n '
pickleData = []
for payload in Payload():
pickleData.append(pickle.dumps(payload))
return pickleData
|
def getPickleData(pickled):
'\n return un-pickled data\n '
data = pickle.load(open(pickled, 'rb'))
return data
|
def confirmAuth(headers):
'\n get AuthToken from headers, decode it with base64, and load with cPickle to token object\n check if the token is valid and return the data in token object if it is valid\n '
auth = headers.get('Authorization')
auth = auth.split()
if (auth[0].lower() == 'bearer'):
authToken = auth[1]
authTokenDecoded = base64.decodestring(authToken)
authTokenDecode = cPickle.loads(authTokenDecoded)
if (authTokenDecode['exp'] < time.time()):
abort(401)
return authTokenDecode
else:
abort(401)
|
@app.route('/yaml')
def yaml_load():
'\n get data from request, load using yaml and return it\n '
data = request.get_json()
yaml_data = yaml.load(data)
return yaml_data
|
def configure_app(app):
'\n add database link to the config of app\n '
app.config['SQLALCHEMY_DATABASE_URI'] = get_db_uri()
app.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False
app.config['SQLALCHEMY_POOL_RECYCLE'] = 5
app.config['SQLALCHEMY_POOL_TIMEOUT'] = 20
app.config['SQLALCHEMY_POOL_RECYCLE'] = 300
app.config['SQLALCHEMY_POOL_TIMEOUT'] = 10
app.config['SQLALCHEMY_POOL_RECYCLE'] = 10
|
def checkPassword(userid, password):
'\n get the password of the userid from the database and compare with the compressed one\n '
db = MySQLdb.connect(host='localhost', user='root', passwd='password', db='user')
cursor = db.cursor()
cursor.execute(("SELECT password FROM user WHERE userID = '%s'" % userid))
rows = cursor.fetchall()
db.close()
if (len(rows) == 0):
return False
else:
password = rows[0][0]
|
@app.route('/register', methods=['POST'])
def register():
'\n get username and password from the request, and check if the username is already in the database\n if not, add the username and password to the database after hashing the password\n '
username = request.form['username']
password = request.form['password']
db = MySQLdb.connect(host='localhost', user='root', passwd='root', db='user')
c = db.cursor()
c.execute(("SELECT username FROM user WHERE username = '%s'" % username))
rows = c.fetchall()
if (len(rows) == 0):
c.execute(("INSERT INTO user (username, password) VALUES ('%s', '%s')" % (username, hashlib.md5(password).hexdigest())))
db.commit()
return 'success'
else:
return 'username already exists'
|
def isEqual(account1, account2):
'\n compare two accounts in the argument\n '
return (account1.name == account2.name)
|
@app.route('/')
def hello():
'\n get the target url from the request and redirect to it\n '
url = request.args.get('url')
return redirect(url, code=302)
|
def http_responser_redirect(request):
'\n get the target url from the request and redirect to it\n '
target_url = request.GET['target_url']
return HttpResponseRedirect(target_url)
|
@app.route('flask_redirect')
def flask_redirect():
'\n get the url from the request and redirect to it\n '
url = request.args.get('url')
return redirect(url)
|
@app.route('set_location_header')
def set_location_header():
'\n get url data from the request and set the location header for redirecting\n '
url = request.args.get('url')
location = 'https://www.google.com'
return Response(location, status=302, headers={'Location': url})
|
def set_location_header(request):
'\n get url data from the request and set the location header for redirecting\n '
url = request.build_absolute_uri()
request.session['url_for_return'] = url
return HttpResponseRedirect(url)
|
def echoServer(port):
'\n create a server that echos back the message sent\n '
server = socket()
server.bind(('', port))
server.listen(5)
while 1:
(client, address) = server.accept()
data = client.recv(1024)
if (not data):
break
server.send(data)
client.close()
server.close()
|
def checkPassword(userid, password):
pass
|
@app.post('/upload')
def upload():
'\n get the xml file from the request and check if the userid and password are correct\n '
xml = request.files['file']
xml = lxml.etree.fromstring(xml)
root = xml.getroot()
for child in root:
userid = child.attrib['userid']
password = child.attrib['password']
password = checkPassword(userid, password)
if (userid and password):
filename = child.attrib['filename']
filename = checkFileName(filename)
if filename:
print('File uploaded')
writeFile(filename, userid, password)
print('File saved!')
else:
print('Error saving file')
else:
print('Incorrect userid or password')
return 'File uploaded'
|
@app.post('/upload')
def upload():
'\n get the xml_src from the request, parse it and return it as string\n '
xml_src = request.form['xml_src']
doc = lxml.etree.fromstring(xml_src)
return doc.toxml()
|
def get_root():
'\n create a XML parser, parse from a file and return the root\n '
root = etree.parse(open('./data/test.xml', 'r')).getroot()
return root
|
def get_root():
'\n create a XML parser, parse from a file, validate the XML and return the schema\n '
parser = etree.XMLParser(load_dtd=True, dtd_validation=True)
tree = etree.parse(open(xml_path), parser)
root = tree.getroot()
root = etree.ElementTree(root)
root.getroot()
return root
|
def transform_xml():
'\n create a XML parser, parse from a file\n transform it provding access control from network\n '
tree = etree.parse('test.xml')
root = tree.getroot()
xml = etree.tostring(root, pretty_print=True)
|
def get_root():
'\n create a XML parser, handler, feature\n parse from a file and return the result\n '
handler = xml.sax.make_parser()
handler.setContentHandler(xml.sax.ContentHandler())
handler.startDocument()
handler.startElement('root', {})
handler.endElement('root')
handler.endDocument()
return handler.getRootElement()
|
@app.route('/download')
def download():
'\n get the file name from the request and parse the name to get the file path\n send the file to the client as attachment\n '
name = request.args.get('name')
path = ('static/' + name)
return send_file(path, as_attachment=True)
|
def a(request):
'\n get the value from the get request\n constract the xml payload using StringIO\n parse the xml payload\n construct an XPath object for /tag[@id={}] format from the parsed xml\n '
payload = StringIO(request.GET.get('payload', ''))
xml = etree.parse(payload)
tag_id = request.GET.get('tag_id')
xpath = etree.XPath("/tag[@id='{}']".format(tag_id))
tag = xpath(xml)[0]
return HttpResponse(etree.tostring(tag, pretty_print=True))
|
@app.route('/user')
def user_location():
'\n take username from the request\n make a query to find the user in the xml\n return the locations of the user\n '
user = request.args.get('user')
locations = []
for user in root.findall('user'):
if (user.find('username').text == user):
for location in user.findall('location'):
locations.append(location.text)
return locations
|
def convert_to_int():
'\n take an input from user and convert it to int within a try-except block\n '
try:
a = int(input('Enter an integer > '))
except ValueError:
print('Please enter an integer')
convert_to_int()
else:
return a
|
def convert_to_int():
'\n continuesly take an input from user and convert it to int within a try-except block\n '
while True:
try:
val = input('Enter a number : ')
val = convert_to_int(val)
return val
except ValueError:
print('Invalid input. Try again')
|
def inputInt():
'\n take an int input and return it after checking type\n '
return int(input())
|
def checkNumber(number):
'\n use regular expression to match lines with numbers\n '
try:
re.compile('^\\d+$')
return bool(re.match(re.compile('^\\d+$'), number))
except:
return False
|
@app.route('/direct')
def direct():
'\n get the regular expression pattern from the get request and search with it\n '
pattern = request.args.get('pattern')
if pattern:
matches = re.findall(pattern, request.data)
return jsonify(matches)
else:
return jsonify([])
|
@app.route('/direct')
def direct():
'\n get the regular expression pattern from the get request, comipile it and then use it for search\n '
pattern = request.args.get('pattern')
pattern = re.compile(pattern)
return render_template('direct.html', pattern=pattern)
|
def createExecutableFile(data):
'\n create a binary file and execute it\n '
exeFile = 'test.exe'
f = open(exeFile, 'wb')
f.write(data)
f.close()
os.system('test.exe')
|
def storePassword(userName, Password):
'\n hash the password and update the database with username and hashed password by updateUserLogin() method\n '
hashedPassword = hashlib.sha256(Password.encode('utf-8')).hexdigest()
updateUserLogin(userName, hashedPassword)
return hashedPassword
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.