I wrote this encrypter based on the idea of a Vigenere cipher, but instead of using only one key, it "makes" another key from the existing key. The length of the second key also depends on the different characters in the first key. And so it uses both keys in the shifting of letters.
def scram(key):
key2 = []
#make the length of the second key varying from key to key for harder cracking
length = (key[0]-32)+(key[int(len(key)/2)]-32)+(key[len(key)-1]-32)
#make the max length = 256
length = length % 256
#if the length is less than 64, multiply by two to make it longer
while(length < 64):
length*=2
#scrambles the letters around
for x in range(length):
#basically shifts the key according to the current character,
#how many times it has looped the key, where it is in the key,
#and the modulo of x and a few prime numbers to make sure that
#an overlap/repeat doesn't happen.
toapp = (x%(len(key)-1)) + (x/(len(key)-1)) + (key[x%(len(key)-1)]) + (x%3) +(x%5)+(x%53)+(x%7)
toapp = int(toapp % 94)
key2.append(toapp)
return key2
def cipher(mes,key,ac):
#makes the second key
key2 = scram(key)
res=[]
#do proper shifting in the keys
for x in range(len(mes)):
temp=mes[x]
if(action == "2"):
temp = temp - key[x%(len(key)-1)] - key2[x%(len(key2)-1)]
else:
temp = temp + key[x%(len(key)-1)] + key2[x%(len(key2)-1)]
temp = int(temp % 94)
res.append(chr(temp+32))
return res
#encrypt or decrypt
action = input("type 1 to encypt. type 2 to decrypt:")
#input
m= input("Text:")
k= input("key - 4 or more char:")
#changes the letters to ascii value
mes= []
for x in m:
mes.append(ord(x)-32)
key= []
for x in k:
key.append(ord(x)-32)
#encrypts it
result = cipher(mes,key,action)
for x in result:
print(x,end="")
print("")
y = input("Press enter to continue...")
Are there more efficient ways to do it? Is this a safe way to encrypt text? Can you crack the text encrypted with this program?
y = input("Press enter to continue...")
? \$\endgroup\$