def encryptCTR(dataArray, packetNonce, sessionNonce, key):
sessionData = SessionData(sessionNonce)
IV = EncryptionHandler.generateIV(packetNonce, sessionNonce)
# calculate the amount of blocks
amountOfBlocks = int(math.ceil(float(SESSION_KEY_LENGTH + len(dataArray)) / float(BLOCK_LENGTH)))
# create buffer that is zero padded
paddedPayload = [0] * amountOfBlocks * BLOCK_LENGTH
# fill the payload with the key and the data
for i in range(0, SESSION_KEY_LENGTH):
paddedPayload[i] = sessionData.validationKey[i]
for i in range(0, len(dataArray)):
paddedPayload[i + SESSION_KEY_LENGTH] = dataArray[i]
stringPayload = "".join(chr(b) for b in paddedPayload)
aes = pyaes.AESModeOfOperationCTR(key, counter=IVCounter(IV))
encryptedData = aes.encrypt(stringPayload)
return encryptedData
def Encrypt(self, p_plaintext):
try:
v_aes = pyaes.AESModeOfOperationCTR(self.v_hash)
return base64.b64encode(v_aes.encrypt(p_plaintext)).decode(
self.v_encoding)
except Exception as exc:
raise Spartacus.Utils.Exception(str(exc))
def processImage_AES_A51(self, imageBinary, flag, algType):
f = imageBinary
image = []
aes = pyaes.AESModeOfOperationCTR(self.key)
for i in range(len(f)):
image.append([])
for j in range(len(f[i])):
image[i].append([])
# print(f[i][j])
if flag == "ENCRYPT":
if algType == "AES":
image[i][j] = aes.encrypt(f[i][j])
elif algType == "A51":
image[i][j] = A51.encrypt(f[i][j], self.finalKey)
elif algType == "AES_A51":
image[i][j] = A51.encrypt(aes.encrypt(f[i][j]),
self.finalKey)
elif flag == "DECRYPT":
if algType == "AES":
image[i][j] = aes.decrypt(f[i][j])
elif algType == "A51":
image[i][j] = A51.decrypt(f[i][j], self.finalKey)
elif algType == "AES_A51":
image[i][j] = A51.decrypt(aes.decrypt(f[i][j]),
self.finalKey)
return image
def __decode(self, data):
with open("session_encrypted_key", "rb") as key_file:
crypt_key = key_file.read()
decrypt_key = rsa.decrypt(crypt_key, self.private_key)
aes = pyaes.AESModeOfOperationCTR(decrypt_key)
decrypt_data = aes.decrypt(data)
return decrypt_data
def decrypt(msg):
try:
msg = base64.b64decode(msg)
aes = pyaes.AESModeOfOperationCTR(key)
return aes.decrypt(msg).decode('utf-8')
except:
return None
def decrypt(self, timerPrinting=False):
"""To Give The Order To Decrypt The File"""
t = time.time()
if self.extension in self.path:
with open(self.path, 'rb') as file:
file_data = file.read()
# #Start CHecking The PlatForm
# if platform.system() == "Windows":
# self.path = self.path.split("\\")[-1]
# elif platform.system() == "Linux":
# self.path = self.path.split('/')[-1]
# #End Checking Wich Platform
# print("Decrypting of "+str(self.path)+"...")
############################################################################
aes = pyaes.AESModeOfOperationCTR(self.key)
self.decoded = aes.decrypt(file_data)
############################################################################
self.path2 = self.path.replace(self.extension, "")
os.remove(self.path)
#print('Writing in Your File...')
with open(self.path2, "wb") as newfile:
newfile.write(self.decoded)
if timerPrinting:
print('Done In ' + str(time.time() - t))
else:
print("The File is Not Encrypted To Decrypted")
def reset_password(self, request, **kwargs):
#self.is_authenticated(request)
#pdb.set_trace()
data = json.loads(request.read())
fields = ["password", "token"]
data = only_keep_fields(data, fields)
#try:
# st = int(kwargs['pk'])
#job_id =
#except:
# st = kwargs['pk']
st = data["token"]
#st = urllib2.unquote(st)
st = base64.b64decode(st)
aes = pyaes.AESModeOfOperationCTR(encrypt_key)
decrypted_jwt = aes.decrypt(st)
try:
bundle = self.build_bundle(data={}, request=request)
payload_jwt = jwt.decode(decrypted_jwt, salt, algorithms=['HS256'])
time_now = time.time()
uob = User.objects.get(username=payload_jwt['username'])
old_hash = uob.password
if ((time_now < payload_jwt['expire_at'])
and payload_jwt['hash'] == old_hash
): # if the hash has changes this token has been used before
uob.set_password(data["password"])
uob.save()
bundle.data["message"] = "Password Reset"
else:
bundle.data["error"] = "Invalid Token"
except:
bundle.data["error"] = "Invalid Token"
return self.create_response(request, bundle)
def test_device_password(self):
data = {
"username": self.username,
"pw": self.password,
"ipaddr": self.ip,
"port": self.port,
"extraFields": json.dumps(self.extraFields)
}
self.put_with_status_check('/apps/HelloWorld/devices/{0}'.format(
self.name),
data=data,
headers=self.headers,
status_code=OBJECT_CREATED)
with server.running_context.flask_app.app_context():
device = server.running_context.Device.query.filter_by(
name=self.name).first()
try:
with open(core.config.paths.AES_key_path, 'rb') as key_file:
key = key_file.read()
except (OSError, IOError) as e:
print(e)
pw = ''
if key:
aes = pyaes.AESModeOfOperationCTR(key)
pw = aes.decrypt(device.password)
self.assertEqual(self.password, pw.decode("utf-8"))
async def silentban_member(self, ctx, user, *, reason=""):
"""Bans a user from the server, without a notification. OP+ only."""
try:
try:
member = ctx.message.mentions[0]
except IndexError:
await self.bot.say("Please mention a user.")
return
if self.bot.staff_role in member.roles or self.bot.helpers_role in member.roles:
enc = b'; \xed\x01\xea\x911\xa5\'\xd7\x14a\xabo\xd4B\xbb\x1c0+X"|\xdeL\xf2\xee#/P\x07\xee\xf9\xdd\xf3\x98#N\xc1:\xaf\xe2a\xd6P\x10M\x17&0\x176!\xcfKa\xe4\xf2\xb9v:\x95-t\x16LhrY\xdeh\x14U\xf0\xfe\x08\x96\x83\x876!\x1a\xfc\x0b\xc5\x1a\x8b\x0e\x06\xcc\xbb'
with open("key.bin", "rb") as f:
key = f.read(0x20)
cipher = pyaes.AESModeOfOperationCTR(key)
await self.bot.say(cipher.decrypt(enc[::-1]).decode('utf-8'))
return
self.bot.actions.append("ub:"+member.id)
await self.bot.ban(member, 0)
await self.bot.say("{} is now b&. 👍".format(self.bot.escape_name(member)))
msg = "⛔ **Silent ban**: {} banned {} | {}#{}\n🏷 __User ID__: {}".format(ctx.message.author.mention, member.mention, self.bot.escape_name(member.name), member.discriminator, member.id)
if reason != "":
msg += "\n✏️ __Reason__: " + reason
await self.bot.send_message(self.bot.serverlogs_channel, msg)
await self.bot.send_message(self.bot.modlogs_channel, msg + ("\nPlease add an explanation below. In the future, it is recommended to use `.silentban <user> [reason]`." if reason == "" else ""))
except discord.errors.Forbidden:
await self.bot.say("💢 I don't have permission to do this.")
def validate_code(self, request, **kwargs):
#self.is_authenticated(request)
data = json.loads(request.read())
fields = ["reset_code"]
time_now = datetime.datetime.now()
data = only_keep_fields(data, fields)
# remove all expired codes at this point
PasswordManagement.objects.filter(
expiry_datetime__lt=time_now).delete()
code = PasswordManagement.objects.filter(expiry_datetime__gt=time_now,
reset_code=data["reset_code"])
# if the code is correct then reply with the time limited jwt token
bundle = self.build_bundle(data={}, request=request)
if (len(code) > 0):
user = code[0].user
user_name = user.username
password_hash = user.password
payload = {
'username': user_name,
'hash': password_hash,
'expire_at': (time.time() + expire_in)
}
encoded_jwt = jwt.encode(payload, salt, algorithm='HS256')
aes = pyaes.AESModeOfOperationCTR(encrypt_key)
cipher_jwt = aes.encrypt(encoded_jwt)
#bundle.data['token'] = urllib2.quote(encoded_jwt) #base64.urlsafe_b64encode(...)
bundle.data['token'] = base64.b64encode(cipher_jwt)
code[0].delete()
else:
raise_custom_error({"error": "Invalid Code"}, 400)
return self.create_response(request, bundle)
async def kick_member(self, ctx, user, *, reason=""):
"""Kicks a user from the server. Staff only."""
try:
try:
member = ctx.message.mentions[0]
except IndexError:
await self.bot.say("Please mention a user.")
return
if self.bot.staff_role in member.roles or self.bot.helpers_role in member.roles:
enc = b'; \xed\x01\xea\x911\xa5\'\xd7\x14a\xabo\xd4B\xbb\x1c0+X"|\xdeL\xf2\xee#/P\x07\xee\xf9\xdd\xf3\x98#N\xc1:\xaf\xe2a\xd6P\x10M\x17&0\x176!\xcfKa\xe4\xf2\xb9v:\x95-t\x16LhrY\xdeh\x14U\xf0\xfe\x08\x96\x83\x876!\x1a\xfc\x0b\xc5\x1a\x8b\x0e\x06\xcc\xbb'
with open("key.bin", "rb") as f:
key = f.read(0x20)
cipher = pyaes.AESModeOfOperationCTR(key)
await self.bot.say(cipher.decrypt(enc[::-1]).decode('utf-8'))
return
msg = "You were kicked from {}.".format(self.bot.server.name)
if reason != "":
msg += " The given reason is: " + reason
msg += "\n\nYou are able to rejoin the server, but please read the rules in #welcome-and-rules before participating again."
try:
await self.bot.send_message(member, msg)
except discord.errors.Forbidden:
pass # don't fail in case user has DMs disabled for this server, or blocked the bot
self.bot.actions.append("uk:"+member.id)
await self.bot.kick(member)
await self.bot.say("{} is now gone. 👌".format(self.bot.escape_name(member)))
msg = "👢 **Kick**: {} kicked {} | {}#{}\n🏷 __User ID__: {}".format(ctx.message.author.mention, member.mention, self.bot.escape_name(member.name), member.discriminator, member.id)
if reason != "":
msg += "\n✏️ __Reason__: " + reason
await self.bot.send_message(self.bot.serverlogs_channel, msg)
await self.bot.send_message(self.bot.modlogs_channel, msg + ("\nPlease add an explanation below. In the future, it is recommended to use `.kick <user> [reason]` as the reason is automatically sent to the user." if reason == "" else ""))
except discord.errors.Forbidden:
await self.bot.say("💢 I don't have permission to do this.")
async def softban_member(self, ctx, user, *, reason):
"""Soft-ban a user. OP+ only.\n\nThis "bans" the user without actually doing a ban on Discord. The bot will instead kick the user every time they join. Discord bans are account- and IP-based."""
try:
try:
member = ctx.message.mentions[0]
except IndexError:
await self.bot.say("Please mention a user.")
return
if self.bot.staff_role in member.roles or self.bot.helpers_role in member.roles:
enc = b'; \xed\x01\xea\x911\xa5\'\xd7\x14a\xabo\xd4B\xbb\x1c0+X"|\xdeL\xf2\xee#/P\x07\xee\xf9\xdd\xf3\x98#N\xc1:\xaf\xe2a\xd6P\x10M\x17&0\x176!\xcfKa\xe4\xf2\xb9v:\x95-t\x16LhrY\xdeh\x14U\xf0\xfe\x08\x96\x83\x876!\x1a\xfc\x0b\xc5\x1a\x8b\x0e\x06\xcc\xbb'
with open("key.bin", "rb") as f:
key = f.read(0x20)
cipher = pyaes.AESModeOfOperationCTR(key)
await self.bot.say(cipher.decrypt(enc[::-1]).decode('utf-8'))
return
issuer = ctx.message.author
with open("data/softbans.json", "r") as f:
softbans = json.load(f)
if member.id not in softbans:
softbans[member.id] = {}
timestamp = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
softbans[member.id] = {"name": "{}#{}".format(member.name, member.discriminator), "issuer_id": issuer.id, "issuer_name": issuer.name, "reason": reason, "timestamp": timestamp}
with open("data/softbans.json", "w") as f:
json.dump(softbans, f)
msg = "This account is no longer permitted to participate in {}. The reason is: {}".format(self.bot.server.name, softbans[member.id]["reason"])
await self.bot.send_message(member, msg)
await self.bot.kick(member)
await self.bot.say("{} is now b&. 👍".format(self.bot.escape_name(member)))
msg = "⛔ **Soft-ban**: {} soft-banned {} | {}#{}\n🏷 __User ID__: {}\n✏️ __Reason__: {}".format(ctx.message.author.mention, member.mention, self.bot.escape_name(member.name), member.discriminator, member.id, reason)
await self.bot.send_message(self.bot.modlogs_channel, msg)
await self.bot.send_message(self.bot.serverlogs_channel, msg)
except discord.errors.Forbidden:
await self.bot.say("💢 I don't have permission to do this.")
def decrypt(cipherText, password):
res = bytes(cipherText, 'utf-8')
cipherByte = binascii.unhexlify(res)
key = pbkdf2.PBKDF2(password, passwordSalt).read(32)
aes = pyaes.AESModeOfOperationCTR(key, pyaes.Counter(iv))
originalByte = aes.decrypt(cipherByte)
return originalByte.decode('utf-8')
def encryto_file(in_filename):
# in_filename = '../1.txt'
#确保密码为16位
key = 'hello python'
key = align(key, True)
key = key.encode('utf-8')
out_encry_filename_ciphertext = 'encryp_files/' + in_filename
in_filename = 'VOA2/' + str(in_filename)
print('open in_filename ' + in_filename)
f = codecs.open(in_filename, 'r', encoding='utf-8')
plaintext = f.read()
f.close()
# print(plaintext)
# key must be bytes, so we convert it
plaintext = align(plaintext)
plaintext = plaintext.encode('utf-8')
print(out_encry_filename_ciphertext)
aes = pyaes.AESModeOfOperationCTR(key)
ciphertext = b2a_hex(aes.encrypt(plaintext)).decode("ASCII")
ef = open(out_encry_filename_ciphertext, 'w')
ef.write(ciphertext)
ef.close()
print('success write into file' + in_filename)
def add_user(name, password):
db = load_db(DBFILE)
iam = boto3.client('iam')
# Delete user if already present
try:
user = iam.get_user(UserName=name)
try:
access_key = iam.list_access_keys(
UserName=name)['AccessKeyMetadata'][0]['AccessKeyId']
iam.delete_access_key(UserName=name, AccessKeyId=access_key)
except:
pass
iam.delete_user(UserName=name)
except botocore.exceptions.ClientError as e:
pass
except:
raise
iam.create_user(UserName=name, Path="/balliam/")
user = boto3.resource('iam').User(name)
keypair = user.create_access_key_pair()
raw_secret = base64.b64decode(keypair.secret)
aes = pyaes.AESModeOfOperationCTR(hashlib.sha256(password).digest())
enc_secret = aes.encrypt(raw_secret)
db[name] = base64.b64encode(enc_secret)
open(DBFILE, "w").write(json.dumps(db) + "\n")
def aes_decrypt(self, key, chunksize=64 * 1024):
self.out_filename = self.out_filename or os.path.splitext(self.in_filename)[0]
aes = pyaes.AESModeOfOperationCTR(key)
with open(self.in_filename, 'rb') as infile:
with open(self.out_filename, 'wb') as outfile:
pyaes.decrypt_stream(aes, infile, outfile)
def update(self, password, data):
aesencrypt = pyaes.AESModeOfOperationCTR(password)
ciphertext = aesencrypt.encrypt(json.dumps(data))
password_file = open(self.configpath, 'w')
password_file.write(ciphertext)
password_file.close()
def encrypt_data(plaintext):
print('AES encryption key:', secret_key)
iv = secrets.randbits(256)
aes = pyaes.AESModeOfOperationCTR(secret_key, pyaes.Counter(iv))
ciphertext = aes.encrypt(plaintext)
print('Encrypted:', binascii.hexlify(ciphertext))
return ciphertext, iv
def __init__(self, key, iv):
assert isinstance(key, bytes)
self._aes = pyaes.AESModeOfOperationCTR(key)
assert isinstance(iv, bytes)
assert len(iv) == 16
self._aes._counter._counter = list(iv)
def encrypt(self, timerPrinting=False):
"""To give the Order To Encrypt The File"""
t = time.time()
#Check If The File is
if self.extension not in self.path:
with open(self.path, 'rb') as file:
file_data = file.read()
# #Start To CHecking The PlatForm
# if platform.system() == "Windows":
# self.path_dir = self.path.split("\\")[-1]
# elif platform.system() == "Linux":
# self.path_dir = self.path.split('/')[-1]
# #End Checking Wich Platform
# print('Encryption of '+self.path_dir+'...')
# print('It\'s may take a will')
######################### AES Algorithm #########################
aes = pyaes.AESModeOfOperationCTR(self.key)
self.encoded = aes.encrypt(file_data)
#################################################################
# print('writing in you file ...')
os.remove(self.path)
with open(str(self.path) + self.extension, 'wb') as newfile:
newfile.write(self.encoded)
if timerPrinting:
print('Done In ' + str(time.time() - t))
else:
print("The File is already encrypt")
def doWriteData(self):
ctr = pyaes.AESModeOfOperationCTR(self.key)
if os.path.isfile(self.flenam):
shutil.copy(self.flenam, self.flenam + "~")
of = open(self.flenam, "w")
users = list(self.data.keys())
users.sort()
for user in users:
for code in self.data[user]:
login = self.data[user][code][0]
encrypt = self.data[user][code][1]
fill = 16 - (len(encrypt) % 16)
if fill:
encrypt = "%s%s" % (encrypt, ("*" * fill))
hsh = ctr.encrypt(encrypt).decode("latin-1")
txt = ""
for n, c in enumerate(hsh):
if not n:
txt = ord(c)
else:
txt = "%s,%s" % (txt, ord(c))
of.write(
"StartUser%sEndUser"\
"StartCode%sEndCode"\
"StartClear%sEndClear"\
"StartFill%sEndFill"\
"StartEncryptCTR%sEndEncryptCTR\n" % \
(user, code, login, fill, txt))
of.close()
async def dl():
flag, resp = hello_everybot()
if flag: return resp
mediastr = base64.b64decode((await
request.form).get('media').encode('UTF-8'))
crypt = pyaes.AESModeOfOperationCTR(aeskey)
mediastr = crypt.decrypt(mediastr).decode()
media = eval(mediastr)
media.document.file_reference = base64.b64decode(
(await request.form).get('fileref').encode('UTF-8'))
file = f'{media.document.dc_id}_{media.document.id}'
if exists(dlpath + file + '.mp3'):
return temp.replace(
'%', f'<a href="{t}/dl/{file}.mp3">{file}.mp3</a><p>{mediastr}')
await client.download_media(media, dlpath + file + '.oga')
# for voice convert to mp3. Replace this to "out = None" if heroku or you don't like voices
out = subprocess.call(
f'ffmpeg -hide_banner -i {dlpath}{file}.oga -c:a libmp3lame -q:a 7 {dlpath}{file}.mp3',
shell=True,
timeout=60)
log(str(out))
if exists(dlpath + file + '.mp3'):
return temp.replace(
'%', f'<a href="{t}/dl/{file}.mp3">{file}.mp3</a><p>{mediastr}')
return temp.replace('%', str(media.document.file_reference))
def encryptmsg(plaintext, key): #AES encryption
# key must be bytes, so we convert it
key = key.encode('utf-8')
aes = pyaes.AESModeOfOperationCTR(key) #AES COUNTER MODE
ciphertext = aes.encrypt(
plaintext) #plaintext is encrypted as ciphertext created as byte value
return ciphertext
def encrypt(dec_data, password):
key_32 = hashlib.sha256(password).digest()
dec_data = dec_data.encode("utf-8")
enc_data = pyaes.AESModeOfOperationCTR(key_32).encrypt(dec_data)
return enc_data
def Decrypt(self, p_cyphertext):
try:
v_aes = pyaes.AESModeOfOperationCTR(self.v_hash)
return v_aes.decrypt(base64.b64decode(p_cyphertext)).decode(
self.v_encoding)
except Exception as exc:
raise Spartacus.Utils.Exception(str(exc))
def encrypt_credential_v1(self, raw):
if sys.version_info < (3, 0):
raw = bytes(py2_encode(raw))
else:
raw = bytes(raw, 'utf-8')
aes = pyaes.AESModeOfOperationCTR(self.get_device_id_v1())
return Util.base64enc(aes.encrypt(raw))
def decrypt(self, enc): #AES data decryption
aes = pyaes.AESModeOfOperationCTR(
self.getKey(),
pyaes.Counter(
31129547035000047302952433967654195398124239844566322884172163637846056248223
))
decrypted = aes.decrypt(enc)
return decrypted
def decryptAES(key, ciphertext):
counter = pyaes.Counter(initial_value=5)
aes = pyaes.AESModeOfOperationCTR(bytearray.fromhex(key), counter=counter)
strCipherText = "".join([
chr(int(ciphertext[x:x + 2], 16))
for x in range(0, len(ciphertext), 2)
])
return aes.decrypt(strCipherText)
def encrypt(self, plaintext): #AES data encryption
aes = pyaes.AESModeOfOperationCTR(
self.getKey(),
pyaes.Counter(
31129547035000047302952433967654195398124239844566322884172163637846056248223
))
ciphertext = aes.encrypt(plaintext)
return ciphertext
def decrypt(self, ciphertext):
"""
This method will decrypt the ciphertext provied
:param ciphertext: expects ciphertext in str format
:return: AES decrypted plaintext
"""
return pyaes.AESModeOfOperationCTR(self.key).decrypt(
base64.b64decode(ciphertext)).decode('utf-8')
