def user2(u,n,p):
u = str(u)
n = str(n)
un = u+", "+n
with open("usersprivate","r") as f:
for line in f:
if un in line or u in line or n in line:
create.place_forget()
failedCreate.place(relwidth = 500, relheight = 500)
win.after(10000,sucfai)
return
with open("usersprivate","a") as f:
f.write("\n")
f.write(un)
f.close()
usern = n
userp = p
randomnumber = str(randint(101,200))
userdata = []
usern = encrypt(usern,randomnumber)
userp = encrypt(userp,randomnumber)
userdata = [usern, userp, randomnumber]
with open("userpassdata","a") as f:
f.write(str(userdata))
f.write("\n")
f.close()
create.place_forget()
successCreate.place(relwidth = 500, relheight = 500)
win.after(5000,sucfai)
return
def test_get_items(self):
passkey = environ.get('REPO_ACCESS_TOKEN')
username = environ.get("TGTG_USERNAME", None)
env_file = environ.get('GITHUB_ENV', None)
timeout = environ.get('TGTG_TIMEOUT', 60)
if passkey:
encrypted_access_token = environ.get("TGTG_ACCESS_TOKEN", None)
encrypted_refresh_token = environ.get("TGTG_REFRESH_TOKEN", None)
encrypted_user_id = environ.get("TGTG_USER_ID", None)
access_token = cryptocode.decrypt(
encrypted_access_token,
passkey) if encrypted_access_token else None
refresh_token = cryptocode.decrypt(
encrypted_refresh_token,
passkey) if encrypted_refresh_token else None
user_id = cryptocode.decrypt(
encrypted_user_id, passkey) if encrypted_user_id else None
else:
access_token = environ.get("TGTG_ACCESS_TOKEN", None)
refresh_token = environ.get("TGTG_REFRESH_TOKEN", None)
user_id = environ.get("TGTG_USER_ID", None)
client = TgtgClient(
email=username,
timeout=timeout,
access_token=access_token,
refresh_token=refresh_token,
user_id=user_id,
)
# get credentials and safe tokens to GITHUB_ENV file
# this enables github workflow to reuse the access_token on sheduled runs
# the credentials are encrypted with the REPO_ACCESS_TOKEN
credentials = client.get_credentials()
if env_file:
with open(env_file, "a") as file:
file.write("TGTG_ACCESS_TOKEN={}\n".format(
cryptocode.encrypt(credentials["access_token"], passkey)))
file.write("TGTG_REFRESH_TOKEN={}\n".format(
cryptocode.encrypt(credentials["refresh_token"], passkey)))
file.write("TGTG_USER_ID={}\n".format(
cryptocode.encrypt(credentials["user_id"], passkey)))
# Tests
data = client.get_items(favorites_only=True)
assert len(data) > 0
for prop in GLOBAL_PROPERTIES:
assert prop in data[0]
for prop in ITEM_PROPERTIES:
assert prop in data[0]["item"]
for prop in PRICE_PROPERTIES:
assert prop in data[0]["item"]["price_including_taxes"]
def DPLogin(request):
if request.method == "POST":
data = json.loads(request.body)
if data["select"] == "Patient":
query = PatientRegister.objects.all().filter(
email=data["email"]).first()
if (query
and cryptocode.decrypt(query.password, encrypt_key) # noqa
== data["password"] # noqa
):
token = cryptocode.encrypt(str(query.id), token_key)
user = {
"id": query.id,
"name": query.name,
"email": query.email,
"login_type": "patient",
}
return JsonResponse({
"token": token,
"user": user,
"msg": "Patient login successful"
})
else:
return HttpResponse("Invalid Credentials", status=404)
elif data["select"] == "Doctor":
query = DoctorRegister.objects.all().filter(
email=data["email"]).first()
if (query
and cryptocode.decrypt(query.password, encrypt_key) # noqa
== data["password"] # noqa
):
token = cryptocode.encrypt(str(query.id), token_key)
user = {
"id": query.id,
"name": query.name,
"email": query.email,
"login_type": "doctor",
}
return JsonResponse({
"token": token,
"user": user,
"msg": "Doctor login successful"
})
else:
return HttpResponse("Invalid Credentials", status=404)
else:
return HttpResponse("bad request", status=404)
else:
return HttpResponse("bad request", status=404)
def DPLogin(request):
if request.method == 'POST':
data = json.loads(request.body)
if data['select'] == 'Patient':
query = PatientRegister.objects.all().filter(email=data['email']).first()
if query and cryptocode.decrypt(query.password,encrypt_key ) == data['password']:
token = cryptocode.encrypt(str(query.id),token_key)
user = {
'id':query.id,
'name':query.name,
'email':query.email,
'login_type':'patient'
}
return JsonResponse(
{
'token':token,
'user':user,
'msg':'Patient login successful'
})
else:
return HttpResponse('Invalid Credentials',status=404)
elif data['select'] == 'Doctor':
query = DoctorRegister.objects.all().filter(email=data['email']).first()
if query and cryptocode.decrypt(query.password,encrypt_key ) == data['password']:
token = cryptocode.encrypt(str(query.id),token_key)
user = {
'id':query.id,
'name':query.name,
'email':query.email,
'login_type':'doctor'
}
return JsonResponse(
{
'token':token,
'user':user,
'msg':'Doctor login successful'
})
else:
return HttpResponse('Invalid Credentials',status=404)
else:
return HttpResponse('bad request',status=404)
else:
return HttpResponse('bad request',status=404)
def Encrypt(self):
text = self.TextEntry.get()
key = self.KeyEntry.get()
result = cryptocode.encrypt(text, key)
self.ResultEntry.config(state="normal")
self.ResultEntry.delete(0, tk.END)
self.ResultEntry.insert(0, result)
def add_password(conn, user_id, app_name, add_password,
user_password): # remove default user_password
'''This will add app and password'''
sql = 'SELECT app_name FROM password WHERE app_name= "' + app_name + '"'
add_password = cryptocode.encrypt(add_password, user_password)
cursor = conn.cursor()
cursor.execute(sql)
if cursor.fetchall() != []:
sql = 'UPDATE password SET password = "******" WHERE app_name = "' + app_name + '";'
if input(color['WARNING'] +
'App name exists in database. Reqrite?(y/n): ' +
color['ENDC'])[0].lower() != 'y':
return
pass
else:
sql = "INSERT INTO password(user_id,app_name, password, ini_date) VALUES('" + str(
user_id
) + "','" + app_name + "', '" + add_password + "', curdate());"
cursor = conn.cursor()
cursor.execute(sql)
conn.commit()
print(color['OKGREEN'] + color['UNDERLINE'] + '\tPassword Added' +
color['ENDC'])
def DoctorRegisterView(request):
if request.method == "POST":
data = json.loads(request.body)
data["password"] = cryptocode.encrypt(data["password"], encrypt_key)
form = DoctorRegisterForm(data)
form.save()
return HttpResponse("Doctor Registered", status=200)
else:
return HttpResponse("bad request", status=404)
def DoctorRegisterView(request):
if request.method == 'POST':
data = json.loads(request.body)
data['password'] = cryptocode.encrypt(data['password'],encrypt_key )
form = DoctorRegisterForm(data)
form.save()
return HttpResponse('Doctor Registered',status=200)
else:
return HttpResponse('bad request',status=404)
def with_variables():
#password for our string
password = "******"
#text to encode
text = "mytext"
#encoding text
encoded = cryptocode.encrypt(text, password)
#printing
print(encoded)
def client():
host = "127.0.0.1"
port = 5001
c = socket.socket()
c.connect((host, port))
message = input("Input:: ")
while message.lower().strip() != 'end':
message = cryptocode.encrypt(message, "mysecret")
c.send(message.encode())
data = c.recv(1024).decode()
data = cryptocode.decrypt(message, "mysecret")
print('Server message: ' + data)
message = input(" >")
c.close()
def asking_for_pass_and_text():
#asking for password for our string
print("Please enter the password")
password = input()
#asking for text to encode
print("Please enter the text")
text = input()
#encoding text
encoded = cryptocode.encrypt(text, password)
#printing
print(encoded)
async def link_src(self, ctx: Context, apikey: str = "") -> None:
if not apikey:
await ctx.reply(
"Please try this command again by getting an api key from"
" <https://www.speedrun.com/api/auth> then do `+link src [API KEY]` in my DMs or"
" anywhere in this server. Be careful who you share this key with. To learn more"
" check out <https://github.com/speedruncomorg/api/blob/master/authentication.md>"
)
return
try:
await ctx.message.delete()
except Forbidden:
await ctx.reply(
"Please delete this message or someone could take control of your speedrun.com user"
)
user = str(hash(ctx.author))
async with self.bot.session.get(
"https://www.speedrun.com/api/v1/profile",
headers={
"X-API-Key": apikey,
},
) as r:
# As soon as we're done with the api key
# Delete it from memory
del apikey
if not r.ok:
print(r.status, await r.text())
return await ctx.reply(
"Something went wrong, please try again later.")
res = await r.json()
src_id = cryptocode.encrypt(res["data"]["id"], str(ctx.author.id))
self.bot.redis.hset("users",
key=f"{user}.{SRC_NAMESPACE}",
value=src_id)
await ctx.send(
f"Linked {ctx.author.mention} to {res['data']['names']['international']}"
)
def generateKeys(self, password):
global public
global private
private = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
public = private.get_verifying_key()
self.publicHex = public.to_string("compressed").hex()
privateHexUsable = private.to_string().hex()
self.privateHex = cryptocode.encrypt(private.to_string().hex(),
password)
self.nonce = 0
self.created = round(time.time(), 2)
file = open("wallet.dat", 'w')
file.write(json.dumps(self.__dict__))
file.close()
self.privateHex = privateHexUsable
def server():
host = "127.0.0.1"
port = 5001
s = socket.socket()
s.bind((host, port))
s.listen(2)
conn, address = s.accept()
print("New Connection From:" + str(address))
while True:
data = conn.recv(1024).decode()
if not data:
break
data = str(data)
data = cryptocode.decrypt(data, "mysecret")
print("User: "******"mysecret")
conn.send(data.encode())
conn.close()
def configFile(self):
import configparser
config = configparser.ConfigParser()
if not os.path.exists("config.ini"):
configDatabase = self.createDatabase()
encoded = cryptocode.encrypt(configDatabase["string"],
configDatabase["password"])
config['database'] = {
"type": configDatabase["type"],
"cluster": encoded
}
with open('config.ini', 'w') as configfile:
config.write(configfile)
return config
else:
config.read('config.ini')
return config
def register_voter():
if request.method == "POST":
if request.form.get:
#gets all the data from the website
fname = request.form.get("fname")
lname = request.form.get("lname")
date = request.form.get("bday")
id_num = request.form.get("id")
password = request.form.get("Password")
#generate keys to be stored
pub, priv = generate_keys()
if collection.count_documents({ "id": id_num }, limit = 1) == 0: # checks if the voter has been already register.
# insert to electors database
#TO DO: use this hash value to verify if the vote has been counted
hash_code = fname+lname+date
hash_result = hashlib.sha256(hash_code.encode()) # generate a hash number from the name and id number.
salt = crypt.mksalt(crypt.METHOD_SHA512) # random salt to add the authen and decrypt hash
hash_encrypt, hash_authenticate = generate_hashes(password, salt) # get hashes to aunthentica and decrypt
priv_encoded = cryptocode.encrypt(priv.exportKey().decode('ascii'), hash_encrypt.hex()) # encrypt private key with hash_enncrypt
# adding to electors's database the id number, the hash for check if voted was countes, boolean if the person votes, public key (plain text, to verify signature from the cl
collection.insert_one({ "id":id_num, "has_voted":False, "pk": pub.exportKey().decode('ascii')})
# adding to password manager the id number, the hash aunthentication, salt and the encrypted private key
password_manager.insert_one({"id":id_num, "hash":hash_authenticate.hex(), "salt":salt, "priv_key":priv_encoded})
flash("The voter with id #"+id_num+" has been registered.")
else:
# in case the voter is already registered.
flash(id_num + " is already registered")
app.logger.info("Voter already registered.")
return render_template("register_voters.html")
return render_template("register_voters.html")
def validate_password(self, input_string_1, input_string_2):
return cryptocode.encrypt(input_string_1, SECRET_KEY) == cryptocode.encrypt(input_string_2, SECRET_KEY)
def validate_value(self, value):
value = super().validate_value(value)
return cryptocode.encrypt(value, SECRET_KEY)
def encode_string_to_url(str):
cryptcode_enc = cryptocode.encrypt(str, os.environ.get("SECRET_KEY"))
percent_enc = parse.quote(cryptcode_enc)
return percent_enc
def enter_passes_to_base():
with open('datainfo.txt', 'w') as f:
password = cryptocode.encrypt(decrypt_key, raw_password)
email = cryptocode.encrypt(decrypt_key, raw_email)
f.write(password + "\n")
f.write(email + "\n")
import os import sys from cryptocode import encrypt, decrypt data = sys.argv[1] password = sys.argv[2] cyphertext = encrypt(data, password) print(cyphertext) myDecryptedMessage = decrypt(cyphertext, password) print(myDecryptedMessage)
Respiration = random.randint(10, 18) # 12-16
Glucose = random.randint(135, 210) # less 140 to 200
Heart_Rate = random.randint(58, 84) # 60-80
Oxygen_Saturation = random.randint(93, 105) # 95 -100
Electro_Cardiogram = random.randint(55, 110) # 60-100
timeUpdate = strftime("%d/%m/%Y %HH :%MM :%SS")
print("Sent to :" + b)
doc_ref.set(
{
'EachPara':
ArrayUnion([{
u"bp":
u"" + str(bp),
u"Body_Tempatature":
u"" + cryptocode.encrypt(str(Body_Tempatature), key),
u"Respiration":
u"" + cryptocode.encrypt(str(Respiration), key),
u"Glucose":
u"" + cryptocode.encrypt(str(Glucose), key),
u"Heart_Rate":
u"" + cryptocode.encrypt(str(Heart_Rate), key),
u"Oxygen_Saturation":
u"" + cryptocode.encrypt(str(Oxygen_Saturation), key),
u"Electro_Cardiogram":
u"" + cryptocode.encrypt(str(Electro_Cardiogram), key),
u'UpdateTime':
u"" + cryptocode.encrypt(str(timeUpdate), key)
}])
},
merge=True,
def encode(self):
text = self.enctext.toPlainText()
password = self.encpass.toPlainText()
encoded = cryptocode.encrypt(text, password)
self.encoutput.setText(encoded)
def data_encrypt(data):
return cryptocode.encrypt(data, base64.b64decode(eval(f"b'{open('key.txt', 'r').read()}'")).decode('utf-8'))
import cryptocode
from Cryptodome.Hash import SHA3_512
aa = input("Are you going to open or create a file? (open/create): ")
if aa == ('open'):
a = input("Whats the title? ")
b = input("What's the password? ")
obj = SHA3_512.new()
obj.update(bytes((a), encoding='utf-8'))
e = (obj.hexdigest())
f = open((e) + ".txt", "r")
encoded = f.read()
decoded = cryptocode.decrypt(encoded, (b))
print(decoded)
if aa == ('create'):
a = input("Whats the title? ")
b = input("What do you want to write? \n\n\n")
c = input("What do you want your password to be? ")
obj = SHA3_512.new()
obj.update(bytes((a), encoding='utf-8'))
e = (obj.hexdigest())
encoded = cryptocode.encrypt((b), (c))
f = open((e) + ".txt", "w")
f.write(encoded)
f.close()
print(encoded)
