I've coded an encryption and decryption program for vigenere cipher but I'm stuck when it comes to involve spaces. What condition could I use to overcome it and ignore it completely
print("Enter the string to be encrypted")
s=input()
print("Enter the key for encryption")
t=input()
r=0
s=list(s)
t=list(t)
key=[]
encrypted=[]
decrypted=[]
#This is the loop for making the key string
for i in range(0,len(s),len(t)):
r=i
for j in range(0,len(t),1):
if(i<len(s)):
if(len(key)<len(s)):
key.append(t[j])
i=i+1
i=r
print("The encrypted key is: ")
key=''.join(key)
print(key)
#This is the code for encrypting the message with the key string
for i in range(0,len(s)):
x = (ord(s[i]) + ord(key[i])) % 26
x += ord('A')
encrypted.append(chr(x))
print("The encrypted string is: ")
encrypted=''.join(encrypted)
print(encrypted)
#For decryption
for i in range(0,len(s)):
x = (ord(encrypted[i]) - ord(key[i])+26) % 26
x += ord('A')
decrypted.append(chr(x))
print("The decrypted string is: ")
decrypted=''.join(decrypted)
print(decrypted)
Here Key string refers to as ->
STRING INPUT - WATERMELON
Key - LEMON
Key string - LEMONLEMON
But it isn't working for sentences. I tried putting in code like
if(s[i]==' '):
continue
but it didn't work
Possible solution, hope it's not too python2
from itertools import cycle
# if python2 uncomment the following
# from itertools import izip as zip
# you can replace these with calls for input()
data = "attack at dawn"
key = "lemon"
# sanitize input
data = "".join(data.upper().split()) # trick to remove all white-space chars
key = key.upper()
print data
print key
ord_A = ord('A')
# encripting
encrypted = []
# looping together the input and the key
# cycle gives an infinite loop over an iterable
for dc, kc in zip(data, cycle(key.upper())):
ec = ord_A + (ord(dc) + ord(kc)) % 26
encrypted.append(chr(ec))
encrypted = "".join(encrypted)
print(encrypted)
# decrypting
decrypted = []
for ec, kc in zip(encrypted, cycle(key.upper())):
dc = ord_A + (ord(ec) - ord(kc)) % 26
decrypted.append(chr(dc))
decrypted = "".join(decrypted)
print(decrypted)```
Related
There is an exercise that I was able to complete where I was tasked with implementing a function easyCrypto() which took a string for input and returned its encryption as follows:
Every character at an odd position i in the alphabet was encrypted with the character at position i + 1, and every character at an even position in the alphabet was encrypted with the character at position i - 1. ('a' becomes 'b', 'b' becomes 'a', 'c' becomes 'd', etc.) Lowercase remained lowercase and uppercase remained uppercase. This is what I wrote:
from string import ascii_letters
def easyCrypto(string):
encrypted = ''
for char in string:
if char in ascii_letters:
ascii_code = ord(char)
if ascii_code % 2 == 1:
encrypted += chr(ascii_code + 1)
else:
encrypted += chr(ascii_code - 1)
else:
encrypted += char
print(encrypted)
>>> easyCrypto('abc')
bad
>>> easyCrypto('ZOO')
YPP
There is a follow-up exercise that instructs me to redo this problem using a dictionary instead of a multiway if statement. I have not succeeded in various attempts, although I have been fairly close at times. I would like to learn where I am going wrong. Here is the last bit I came up with:
from itertools import chain
def easyCrypto(string):
asciiDict = dict()
asciiNum = chain(range(65,91), range(97,123))
for i in asciiNum:
asciiDict[str(i)] = chr(i)
for j in range(0, len(string)):
encrypted = ''
for string[j] in asciiDict.keys():
val = asciiDict[string[j]]
while val % 2 == 1:
encrypted += asciiDict[string[j]+1]
else:
encrypted += asciiDict[string[j]-1]
return encrypted
t = {i: i-(-1)**i
for a in [65, 97]
for i in range(a, a+26)}
def easyCrypto(string):
print(string.translate(t))
easyCrypto('abc')
easyCrypto('ZOO')
You need to build the dictionary first, after that loop over the string
from itertools import chain
def easyCrypto(string):
asciiDict = dict()
asciiNum = chain(range(65,91), range(97,123))
for i in asciiNum:
asciiDict[i] = chr(i)
encrypted = ''
for cha in string:
val = ord(cha)
if val % 2 == 1:
encrypted += asciiDict[val+1]
else:
encrypted += asciiDict[val-1]
return encrypted
I am trying to make a decrypt script for a Caeser cipher script to encrypt but can't get it to work. This is my encryption script:
def encrypt(text,s):
result = ""
# traverse text
for i in range(len(text)):
char = text[i]
# Encrypt uppercase characters
if (char.isupper()):
result += chr((ord(char) + s-65) % 26 + 65)
# Encrypt lowercase characters
else:
result += chr((ord(char) + s - 97) % 26 + 97)
return result
#def decrypt(ciphertext, s):
text = "0123456789"
s = 4
Cipher=encrypt(text,s)
print("Text : " + text)
print ("Shift : " + str(s))
print ("Cipher: " + encrypt(text,s))
I need help with creating a decrypt script the same way.
Thanks in advance!
Here is some code of mine for a function used to decrypt a ceaser cipher. The approach used when the shift is not known is simply to get every possible value, then pick the one with more then half the decoded words being in the English dictionary. For non alphabetic characters, there is a placeholder character used.
There are some extra parts required, such as the dictionary or extra functions / lists so I will include them in the below links.
A note, it does only work for on lowercase letters however, I do hope it will help you to understand the logic a bit better.
def Decode(message, shift=-1):
"""
Decodes a message from a caesar cipher
Params:
- message (str) : Message to decode
Optional Params:
- shift (int) : If shift is known
Returns:
- decodedMessage (str) : The decoded message
"""
decodedMessage = ''
message = message.lower() # lowercase is easier to work with
# If the shift is known it is simple to decode
if shift != -1:
for letterIndex in range(len(message)):
if message[letterIndex] in [' ', '!', '?', '.', '-', ',', '_']:
decodedMessage += message[letterIndex]
else:
try:
index = ALPHABET.index(message[letterIndex]) - shift
# If the index is smaller then ALPHABET, handle it
while index < 0:
index += len(ALPHABET)
decodedMessage += ALPHABET[index]
except Exception as e:
print("A problem occured:", e)
decodedMessage += '?'
return decodedMessage
else: #If shift is not known, figure it out thru brute force
data = read_json('words_dictionary')
for i in range(len(ALPHABET)):
decodedMessage = Decode(message, i+1)
wordList = decodedMessage.split(" ")
try:
# Loop over words counting english words
count = 0
for word in wordList:
if word in data.keys():
count += 1
# More accurate this way compared to only one word checks
if count > len(wordList) / 2:
return decodedMessage
except KeyError:
continue
Full code here
Word dictionary here
This question already has answers here:
Repeat string to certain length
(15 answers)
Closed 5 months ago.
In school we are currently using python to create a Caeser Cipher, and a Keyword Cipher. I need help with certain parts of the Keyword cipher, mainly repeating a word to match the length of a string that has been entered, For example:
Entered String: Hello I am Jacob Key: bye Printed text: byebyebyebyeb
I'm okay at Python, but this is very hard for me. Currently this is as far as I got:
def repeat_to_length(key, Input):
return (key * ((ord(Input)/len(key))+1))[:ord(Input)]
Since It's a string I thought if I used ord It would turn it to a number, but I realised when using the ord command you can only have a single character, as I realised when I repeatedly got this error:
TypeError: ord() expected a character, but string of length 16 found
I found some code that did a keyword cipher, but I am not sure which part does the process I am trying to code:
def createVigenereSquare():
start = ord('a')
end = start + 26
index = start
sq = [''] * 256
for i in range(start, end):
row = [''] * 256
for j in range(start, end):
if index > (end - 1):
index = start
row[j] = chr(index)
index += 1
sq[i] = row
index = i + 1
return sq
def createKey(message, keyword):
n = 0
key = ""
for i in range(0, len(message)):
if n >= len(keyword):
n = 0
key += keyword[n]
n += 1
return key
def createCipherText(message, key):
vsquare = createVigenereSquare()
cipher = ""
for i in range(0, len(key)):
cipher += vsquare[ord(key[i])][ord(message[i])]
return cipher
message = str(input("Please input a message using lowercase letters: "))
keyword = str(input("Please input a single word with lowercase letters: "))
key = createKey(message, keyword)
ciphertext = createCipherText(message, key)
print ("Message: " + message)
print ("Keyword: " + keyword)
print ("Key: " + key)
print ("Ciphertext: " + ciphertext)
As I've said I'm only okay at Python, so I don't really understand all the code in the above code, and I really want to be able to write most of it myself.
This is my code so far:
def getMode():
while True:
print("Enter encrypt, e, decrypt or d")
mode = input('Do you want to encrypt the message or decrypt? ') #changes whether the code encrypts or decrypts message
if mode in 'encrypt e decrypt d ENCRYPT E DECRYPT D'.split(): #defines the various inputs that are valid
return mode
else:
print('Enter either "encrypt" or "e" or "decrypt" or "d".') #restarts this string of code if the input the user enters is invalid
Input = input('Enter your message: ')
key = input('Enter the one word key: ')
def repeat_to_length(key, Input):
return (key * ((ord(Input)/len(key))+1))[:ord(Input)]
encryptedKey = repeat_to_length(key, Input)
print(encryptedKey)
I know I've been pretty long winded but if anyone could provide any information on this topic, like explaining the code for the keyword cipher, or just answering my question, I would appreciate it!
AnimeDeamon
Another possibility is to repeat the key enough times to get a string at least as long as the message, and then just grab as many characters as you need from the beginning:
>>> message='Hello I am Jacob'
>>> key='bye'
>>> times=len(message)//len(key)+1
>>> print((times*key)[:len(message)])
byebyebyebyebyeb
We compute times by dividing the length of the message by the length of the string, but we have to add 1, because any remainder will be dropped. times*key is just key repeated times times. This may be longer than we want, so we just take the first len(message) characters.
A simple one-liner could be
''.join(key[i % len(key)] for i in range(len(message)))
What it does, inside out:
We iterate over the indices of the letters in the string message
For each index, we take the remainder after division with the key length (using the % operator) and get the corresponding letter from the key
A list of these letters is constructed (using list comprehension) and joined together to form a string (the join method of an empty string)
Example:
>>> message = "Hello I am Jacob"
>>> key = "bye"
>>> print ''.join(key[i % len(key)] for i in range(len(message)))
byebyebyebyebyeb
My question is how to improve the code so that it can adapt to however long the input message is. As is, the message must be 5 letters. I would like to improve the code such that a message of any length can be inputted and the cipher will work with it. Help would be much appreciated. :-) See the code below!
#Enter your message
message=raw_input('Enter your message here. Make sure to use all CAPS througout your message and leave no spaces in between words.')
length=len(message)
print 'The length of your message is ',length
#This statement is a possible idea to let the program know how many letters it will be need to shift. But I don't know how to actually do this.
print chr(length+64)
#Indexes letters out of message.
A=message[length-length]
B=message[length-length+1]
C=message[length-length+2]
D=message[length-length+3]
E=message[length-length+4]
#Shifts letters and accounts for shifting XYZ to ABC.
def shift(x):
if ord(x)+3==91:
return 65
if ord(x)+3==92:
return 66
if ord(x)+3==93:
return 67
else:
return ord(x)+3
a2=shift(A)
b2=shift(B)
c2=shift(C)
d2=shift(D)
e2=shift(E)
#Converts shifted ordinals back to characters
def convert(x):
return chr(x)
first=convert(a2)
second=convert(b2)
third=convert(c2)
fourth=convert(d2)
fifth=convert(e2)
#Prints resultant characters
print first,second,third,fourth,fifth
import string
shift_amt = 13
alphabet_lc = string.ascii_lowercase
shifted_lc = alphabet_lc[shift_amt:]+alphabet_lc[:shift_amt]
alphabet_uc = alphabet_lc.upper()
shifted_uc = shifted_lc.upper()
trans_tab = string.maketrans(alphabet_lc+alphabet_uc,shifted_lc+shifted_uc)
message = "Encode Me To a new MessaGez!"
print message.translate(trans_tab)
is one way of doing it in Python2 at least
Use two for loops, one for looping through each character, and one for shifting the character the desired amount of times. We use a function upper() to shift a character.
def upper(char):
from string import ascii_letters as _all
if char == ' ':
return ' '
return _all[_all.index(char)+1] if char != 'Z' else 'a'
def shift(message, key):
temp = []
for i in message:
char = i
for k in range(key):
char = upper(char)
temp.append(char)
return ''.join(temp)
message=raw_input('Enter your message here: ')
key = int(raw_input('Enter the desired key: '))
length=len(message)
print 'The length of your message is', length
print 'Your encrypted message is {0}'.format(shift(message, key))
This runs as:
bash-3.2$ python caesar.py
Enter your message here: This works WITH or without CAPS
Enter the desired key: 10
The length of your message is 31
Your encrypted message is drsC GyBuC gSdR yB GsDryED MKZc
bash-3.2$
The Ceasar cipher is built in in python 2;
In [6]: 'The Caesar cipher is built-in.'.encode('rot13')
Out[6]: 'Gur Pnrfne pvcure vf ohvyg-va.'
As you can see, this encoding only acts on letters, and it works for upper and lower case.
But is you want to remove spaces and make every thing upper-case, Python can do that as well;
In [9]: 'this is a string'.translate(None, ' \t')
Out[9]: 'thisisastring'
In [10]: 'this is a string'.translate(None, ' \t').upper()
Out[10]: 'THISISASTRING'
In [11]: 'this is a string'.translate(None, ' \t').upper().encode('rot13')
Out[11]: 'GUVFVFNFGEVAT'
Or in a different way;
In [15]: ''.join('this is a string'.split()).upper().encode('rot13')
Out[15]: 'GUVFVFNFGEVAT'
Bibliography:
Kid Snippets: "Math Class" (Imagined by Kids) - YouTube http://youtu.be/KdxEAt91D7k
Mary Had A Little Lamb Nursery Rhyme With Lyrics - YouTube http://youtu.be/CkRdvGmcCBE
Mary Had a Little Lamb - Wikipedia, the free encyclopedia http://goo.gl/FNEuyd
Python source code:
Note: working for negative shift numbers also
Note: if reverse shift then we do encode - decode message
Note: preserving spaces also
small_chars = [chr(item) for item in range(ord('a'), ord('z')+1)]
upper_chars = [item.upper() for item in small_chars]
def encode_chr(chr_item, is_upper_case):
'''
Cipher each chr_item.
'''
# setting orig and end order.
if is_upper_case:
orig_ord = ord('A')
end_ord = ord('Z')
else:
orig_ord = ord('a')
end_ord = ord('z')
# calculating shift
temp_ord = ord(chr_item)+shift
# calculating offset order with modulo.
# char is after end_ord, calculating offset
num_of_chars = 26
offset_ord = (temp_ord - end_ord - 1)%num_of_chars
return chr(orig_ord + offset_ord)
# enable while loop to repeat until status not 'y'
status = 'y'
while status == 'y':
# enter word to cipher.
word = raw_input("Word: ")
# enter char shift
shift = input("Shift: ")
print
# create cipher list variable
cipher = list()
# loop trough each char in word
for chr_item in word:
# encode just letters.
# replace non-alfa with underscore: "_"
if chr_item in upper_chars or chr_item in small_chars:
# set is_uppser_case to True for upper case chars.
is_upper_case = (chr_item in upper_chars) and True
# cipher char.
temp_chr = encode_chr(chr_item, is_upper_case)
# append ciphered char to list
cipher.append(temp_chr)
elif chr_item is ' ':
cipher.append(chr_item)
else:
cipher.append('_')
# print word
print word
# print ciphered word
print ''.join(cipher)
# repeat again for another word?
status = raw_input("Repeat? [y|n]: ")
print
Test cases:
>>>
Word: aAzZ!#
Shift: 1
aAzZ!#
bBaA__
Repeat? [y|n]: y
Word: aAzZ#!
Shift: -1
aAzZ#!
zZyY__
Repeat? [y|n]: y
Word: aAzZ#$
Shift: 27
aAzZ#$
bBaA__
Repeat? [y|n]: y
Word: aAzZ%^
Shift: -27
aAzZ%^
zZyY__
Repeat? [y|n]: n
>>>
Output:
Note: if reverse shift then we do encode - decode message
>>>
Word: "Mary Had a Little Lamb"
Shift: 1
"Mary Had a Little Lamb"
_Nbsz Ibe b Mjuumf Mbnc_
Repeat? [y|n]: y
Word: _Nbsz Ibe b Mjuumf Mbnc_
Shift: -1
_Nbsz Ibe b Mjuumf Mbnc_
_Mary Had a Little Lamb_
Repeat? [y|n]: n
>>>
Here is a simple Caesar cipher program written for Python 3 that should not be very difficult to rewrite for Python 2:
import string
def main():
key = 5
table = str.maketrans(string.ascii_letters,
string.ascii_lowercase[key:] +
string.ascii_lowercase[:key] +
string.ascii_uppercase[key:] +
string.ascii_uppercase[:key])
plaintext = input('Please enter a phrase: ')
ciphertext = plaintext.translate(table)
print('Your encrypted phrase is:', ciphertext)
if __name__ == '__main__':
main()
I need help with my ceaser cipher code. I need to be able to shift/decrypt a letter even when the shift value is greater than 122. My code only works for shift values that are less than 22. The code fails when the user specifies an input for the shifter that is greater than 122 How can I do this? For a with shifter 123 the output should be r
k = int(raw_input("Please enter a value for k: ")) #Shifter number
original = raw_input("plaintext: ") #Message user wants ciphered
original_as_array = list(original) ##I am turning the input into an array
for i in range(0,len(original)): ##Now seperating each character to add k
char = original_as_array[i]
charint = ord(char)
if charint >= 65 and charint <=90:
cipher_int = ((charint-65 + k) % 26)+65
code_char = chr(cipher_int)
print code_char,
elif charint >= 97 and charint <=122:
cipher_int = ((charint-97 + k) % 26)+97
code_char = chr(cipher_int)
print code_char,
else:
print char,
#Caesar Cipher
#Function that reads and writes data to the file, and calls the encryption and decryption methods.
#It isolates the key and choice of the user, and then calls the appropriate function.
def isolate():
#Open input file in read mode
fin = open('Input3.txt', 'r')
#Open output file in write mode
fout = open('Out1.txt', 'w')
#Create a list that holds each line of the file as an element of the list
container = fin.readlines()
#For loop that goes through each line of the file (contianed in list) and isolates the choice and key of the user
#Then it removes the key and choice from the split input list and calls the appropriate method.
for i in container:
# List of words, with whitespace and trailing '\n' removed
words = i.split()
# Interpret and remove the last two words
key = int(words[len(words) - 1])
choice = words[len(words) - 2]
words.remove(str(key))
words.remove(choice)
# Re-join the words of the message. The message may differ from the original if there is consecutive whitespace.
message = ' '.join(words)
message = message.upper()
# Encrypt or decrypt to fout
if choice == 'e':
fout.write(encrypt(message, key) + '\n')
else:
fout.write(decrypt(message, key) + '\n')
#Close the file to make sure data is written properly to the file.
fout.close()
#Encryption method, which takes two parameters, the users message and key, and returns the newly encrypted message.
def encrypt(message, key):
#Empty string that will contain the encrypted message.
encrypted_message = ""
#Alphabet string, which contains all the letters of the alphabet at their index locations.
alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
#For loop that goes through each character of the users message and, if a space, adds it straight to the encrypted message or encrypts it through modular division.
for i in message:
#If the character is a space, add it to the final message.
if i == ' ':
#Concatenate the space to the final message
encrypted_message += ' '
#If the character is not a space, determine the final locatin out of index range, % by 26 and re-add the character at this index to the encrypted_message.
else:
#Determine the final location of the character (out of index range)
location = key + alpha.index(i)
#% this location by 26 to determine the location within the proper index.
location %= 26
#Finally, concatenate the letter at this location to the final message.
encrypted_message += alpha[location]
#When the function is called, have it return the final encrypted message.
return encrypted_message
#Decryption method that takes two parameters, the users message and key
def decrypt(message, key):
#Create a string that reverses the alphabet, since we are moving backwards when we decrypt.
reverse_alpha = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'[::-1]
decrypted_message = ""
#For loop that runs through each element of the users message and, if space, adds it to the message, or encrypts using % division, then concatenates to final message.
for i in message:
if i == ' ':
decrypted_message += ' '
else:
#Determine the final location out of index range of the encrypted character
location = key + reverse_alpha.index(i)
#% this position by 26 to determine the index location in range of the letter.
location %= 26
#Finally, add the letter at this location to the decrypted message.
decrypted_message += reverse_alpha[location]
#Converts the decrypted message into lowercase form.
decrypted_message = decrypted_message.lower()
return decrypted_message
#Call the function isolate5(), which initiates the program.
isolate()
Your code fails because you didn't specify a condition when ord(char) > 122. Instead, you threw it to the else clause.
You can just cut the part <= 122:
for k in range(20):
for i in range(0,len(original)): ##Now seperating each character to add k
char = original[i]
charint = ord(char)
if charint >= 65 and charint <=90:
cipher_int = ((charint-65 + k) % 26)+65
code_char = chr(cipher_int)
print code_char,
elif charint >= 97:
cipher_int = ((charint-97 + k) % 26)+97
code_char = chr(cipher_int)
print code_char,
else:
print char,
With k set to 18, this will produce r. If this solution wasn't what you meant, feel free to coment below!