English translation

Esempio.py

@@ -1,9 +0,0 @@
-from crittografia.unicode import codifica
-
-stringa = codifica("Testo da cifrare.")
-a = stringa.rot13()
-b = stringa.vigenère(verme="verme")
-c = stringa.vernam()
-d = stringa.gödel(primo=1117)
-
-print(a, b, c, d, sep="\n")

License.txt

@@ -1,10 +0,0 @@
- * Crittografia
- *
- * Pacchetto di cifrari storici e famosi in python 3
- *
- * Dual licensed under the MIT and GPL licenses:
- * http://www.opensource.org/licenses/mit-license.php
- * http://www.gnu.org/licenses/gpl.html
- * 
- * @author Michele Guerini Rocco aka Rnhmjoj
- * @since 2012

README.md

@@ -1,34 +1,37 @@
-# Crittografia
+# Crypto
 
 
-## Pacchetto di cifrari storici e famosi in python 3
+## Package of historical and famous ciphers in python 3
 
-### Informazioni
+### Info
-Una raccolta di cifrari storici e famosi in python 3.
+A collection of historical and famous ciphers in python 3.
-Per ora contiene:
+For now it contains:
 * ROT13;
-* Cifrario di Vigenère;
+* Vigenere cipher;
-* Cifrario di Vernam
+* Vernam cipher
-* Numero di Gödel
+* Gödel numbering
 
-Si può scegliere se codificare solo lettere dell'alfabeto, caratteri ASCII o unicode UTF-8 a seconda del modulo che si importa.
+You can choose whether to encrypt only the letters of the alphabet, ASCII or Unicode UTF-8 depending on the module that you import.
+It is able to generate a onetimepad for the Vernam cipher with true random numbers from the microphone via [pyaudio](http://people.csail.mit.edu/hubert/pyaudio/).
 
-È in grado di generare un onetimepad per il cifrario di Vernam con numeri casuali veri dal microfono tramite il modulo [pyaudio](http://people.csail.mit.edu/hubert/pyaudio/).
+### Instruction
-
+Encryption:
-### Istruzioni
-Codifica:
 	
-	*.rot13(stringa): stringa da codificare;
+	*.rot13(string): string to be encoded;
-	*.vigenère(stringa,verme): stringa da codificare e verme(chiave di codifica);
+	*.vigenere(string, worm): string to encode and worm (encryption key);
-	*.vernam(stringa): stringa da codificare;
+	*.vernam(string): string to be encoded;
-	*.gödel(stringa,primo): stringa da codificare e un numero primo(è consigliabile di alcune migliaia di cifre);
+	*.godel(string, first): string to be encoded and a prime number (a few thousand digits are recommended);
+Decryption:
 
-Decodifica:
+	*.rot13(string): encoded string;
-	
+	*.vigenere(string, worm) encoded string and worm (encryption key);
-	*.rot13(stringa): stringa codificata;
+	*.vernam(string, pad): encoded string and onetimepad in a tuple;
-	*.vigenère(stringa,verme): stringa codificata e verme(chiave di codifica);
+	*.godel(string, first, n): encoded string, number and length of the first decoded string;	
-	*.vernam(stringa,pad): stringa codificata e il onetimepad in una tupla;
+
-	*.gödel(stringa,primo,n): stringa codificata, numero primo e lunghezza della stringa decodificata;
+### Usage
-	
+In "example.py" there is an example of the use of each function.
-### Utilizzo
+
-Nel file "Esempio.py" c'è un esempio di utilizzo di ogni funzione.
+### License
+Dual licensed under the MIT and GPL licenses:
+http://www.opensource.org/licenses/mit-license.php
+http://www.gnu.org/licenses/gpl.html

crittografia/__init__.py

@@ -1,3 +0,0 @@
-from .alfabeto import *
-from .unicode import *
-from .numeri import *

crittografia/alfabeto.py

@@ -1,126 +0,0 @@
-from .numeri import *
-
-alfa = tuple("abcdefghijklmnopqrstuvwxyz")
-ord = {k: i for i, k in enumerate(alfa)}
-
-
-class codifica:
-
-	def __init__(self, valore):
-		"""
-		Inizializzazione
-		Fornire una stringa da crittografare.
-		"""
-		self.stringa = valore.lower().replace(" ", "")
-
-	def rot13(self):
-		"""
-		Cifrario ROT13
-		"""
-		rotazione = str.maketrans(
-			"abcdefghijklmnopqrstuvwxyz",
-			"nopqrstuvwxyzabcdefghijklm"
-		)
-		return str.translate(self.stringa, rotazione)
-
-	def vigenère(self, verme):
-		"""
-		Cifrario di vigenère
-		Fornire una chiave alfabetica di lunghezza
-		minore della stringa. (verme)
-		"""
-		cifrata = []
-		for i, lettera in enumerate(self.stringa):
-			cifrata.append(
-				alfa[(ord[lettera] + ord[verme[i % len(verme)]]) % 26]
-			)
-		return "".join(cifrata)
-
-	def gödel(self, primo=2):
-		"""
-		Numero di Gödel
-		Specificare un numero primo di partenza.
-		"""
-		cifrata = 1
-		sequenza = primi.primi(primo, len(self.stringa))
-		for i, lettera in enumerate(self.stringa):
-			cifrata *= next(sequenza) ** (ord[lettera] + 1)
-		return cifrata
-
-	def vernam(self, pad=()):
-		"""
-		Cifrario di Vernam
-		Se non si fornisce un one-time-pad ne viene generato
-		uno in automatico.
-		"""
-		cifrata = []
-		if pad is ():
-			pad = generatore.onetimepad(len(self.stringa))
-		for i, lettera in enumerate(self.stringa):
-			cifrata.append(
-				alfa[(ord[lettera] + pad[i]) % 26]
-			)
-		return "".join(cifrata), pad
-
-
-class decodifica:
-
-	def __init__(self, valore):
-		"""
-		Inizializzazione
-		Fornire una stringa o un numero (di gödel) da decrittografare.
-		"""
-		if str(valore).isnumeric():
-			self.numero = valore
-		else:
-			self.stringa = valore.lower().replace(" ", "")
-
-	def rot13(self):
-		"""
-		Cifrario ROT13
-		"""
-		rotazione = str.maketrans(
-			"nopqrstuvwxyzabcdefghijklm",
-			"abcdefghijklmnopqrstuvwxyz"
-		)
-		return str.translate(self.stringa, rotazione)
-
-	def vigenère(self, verme):
-		"""
-		Cifrario di vigenère
-		Fornire la chiave usata per crittografare la stringa. (verme)
-		"""
-		decifrata = []
-		for i, lettera in enumerate(self.stringa):
-			decifrata.append(
-				alfa[(ord[lettera] - ord[verme[i % len(verme)]]) % 26]
-			)
-		return "".join(decifrata)
-
-	def gödel(self, n, primo=2):
-		"""
-		Numero di Gödel
-		Specificare un numero primo di partenza e
-		la lunghezza della stringa.
-		"""
-		decifrata = []
-		for i in primi.primi(primo, n):
-			lettera = -1
-			r, s = 0, self.numero
-			while s % i == 0:
-				r += 1
-				s //= i
-			decifrata.append(alfa[r - 1 % 26])
-		return "".join(decifrata)
-
-	def vernam(self, pad):
-		"""
-		Cifrario di Vernam
-		Fornire il one-time-pad usato per crittografare la stringa.
-		"""
-		cifrata = []
-		for i, lettera in enumerate(self.stringa):
-			cifrata.append(
-				alfa[(ord[lettera] - pad[i]) % 26]
-			)
-		return "".join(cifrata)

crittografia/unicode.py

@@ -1,124 +0,0 @@
-from .numeri import *
-
-max = 2 ** 16
-
-
-class codifica:
-
-	def __init__(self, valore):
-		"""
-		Inizializzazione
-		Fornire una stringa da crittografare.
-		"""
-		self.stringa = valore
-
-	def rot13(self):
-		"""
-		Cifrario ROT13
-		"""
-		rotazione = str.maketrans(
-			"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
-			"nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM"
-		)
-		return str.translate(self.stringa, rotazione)
-
-	def vigenère(self, verme):
-		"""
-		Cifrario di vigenère
-		Fornire una chiave alfabetica di lunghezza
-		minore della stringa. (verme)
-		"""
-		cifrata = []
-		for i, lettera in enumerate(self.stringa):
-			cifrata.append(
-				chr((ord(lettera) + ord(verme[i % len(verme)])) % max)
-			)
-		return "".join(cifrata)
-
-	def gödel(self, primo=2):
-		"""
-		Numero di Gödel
-		Specificare un numero primo di partenza.
-		"""
-		cifrata = 1
-		sequenza = primi.primi(primo, len(self.stringa))
-		for i, lettera in enumerate(self.stringa):
-			cifrata *= next(sequenza) ** ord(lettera)
-		return cifrata
-
-	def vernam(self, pad=()):
-		"""
-		Cifrario di Vernam
-		Se non si fornisce un one-time-pad ne viene generato
-		uno in automatico.
-		"""
-		cifrata = []
-		if pad is ():
-			pad = generatore.onetimepad(len(self.stringa))
-		for i, lettera in enumerate(self.stringa):
-			cifrata.append(
-				chr((ord(lettera) + pad[i]) % max)
-			)
-		return "".join(cifrata), pad
-
-
-class decodifica:
-
-	def __init__(self, valore):
-		"""
-		Inizializzazione
-		Fornire una stringa o un numero (di gödel) da decrittografare.
-		"""
-		if str(valore).isnumeric():
-			self.numero = valore
-		else:
-			self.stringa = valore
-
-	def rot13(self):
-		"""
-		Cifrario ROT13
-		"""
-		rotazione = str.maketrans(
-			"nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM",
-			"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
-		)
-		return str.translate(self.stringa, rotazione)
-
-	def vigenère(self, verme):
-		"""
-		Cifrario di vigenère
-		Fornire la chiave usata per crittografare la stringa. (verme)
-		"""
-		decifrata = []
-		for i, lettera in enumerate(self.stringa):
-			decifrata.append(
-				chr((ord(lettera) - ord(verme[i % len(verme)])) % max)
-			)
-		return "".join(decifrata)
-
-	def gödel(self, n, primo=2):
-		"""
-		Numero di Gödel
-		Specificare un numero primo di partenza e
-		la lunghezza della stringa.
-		"""
-		decifrata = []
-		for i in primi.primi(primo, n):
-			r, s = 0, self.numero
-			while s % i == 0:
-				r += 1
-				s //= i
-			decifrata.append(chr(r % max))
-		return "".join(decifrata)
-
-	def vernam(self, pad):
-		"""
-		Cifrario di Vernam
-		Fornire il one-time-pad usato per crittografare la stringa.
-		"""
-		cifrata = []
-		for i, lettera in enumerate(self.stringa):
-			cifrata.append(
-				chr((ord(lettera) - pad[i]) % max)
-			)
-		return "".join(cifrata)

crypto/__init__.py

@@ -0,0 +1,3 @@
+from .alpha import *
+from .unicode import *
+from .numbers import *

crypto/alpha.py

@@ -0,0 +1,117 @@
+from .numbers import *
+
+alpha = tuple("abcdefghijklmnopqrstuvwxyz")
+ord = {k: i for i, k in enumerate(alpha)}
+
+
+class encrypt:
+
+	def __init__(self, value):
+		"""
+		Initialization
+		Provide a string to encrypt.
+		"""
+		self.string = value.lower().replace(" ", "")
+
+	def rot13(self):
+		"""
+		ROT13 Cipher
+		"""
+		rotation = str.maketrans(
+			"abcdefghijklmnopqrstuvwxyz",
+			"nopqrstuvwxyzabcdefghijklm")
+		return str.translate(self.string, rotation)
+
+	def vigenere(self, worm):
+		"""
+		vigenère Chiper
+		Provide an alphabetical key length less than the string (worm).
+		"""
+		encrypted = []
+		for i, character in enumerate(self.string):
+			encrypted.append(
+				alpha[(ord[character] + ord[worm[i % len(worm)]]) % 26])
+		return "".join(encrypted)
+
+	def godel(self, prime=2):
+		"""
+		Gödel number
+		Provide a prime.
+		"""
+		encrypted = 1
+		sequence = primes.primes(prime, len(self.string))
+		for i, character in enumerate(self.string):
+			encrypted *= next(sequence) ** (ord[character] + 1)
+		return encrypted
+
+	def vernam(self, pad=()):
+		"""
+		Vernam Cipher
+		A one-time-pad will be generated automatically if not provided.
+		"""
+		encrypted = []
+		if pad is ():
+			pad = generator.onetimepad(len(self.string))
+		for i, character in enumerate(self.string):
+			encrypted.append(
+				alpha[(ord[character] + pad[i]) % 26])
+		return "".join(encrypted), pad
+
+
+class decrypt:
+
+	def __init__(self, value):
+		"""
+		Initialization
+		Provide a string or a number (Gödel) to decrypt.
+		"""
+		if str(value).isnumeric():
+			self.numero = value
+		else:
+			self.string = value.lower().replace(" ", "")
+
+	def rot13(self):
+		"""
+		ROT13 Chiper
+		"""
+		rotation = str.maketrans(
+			"nopqrstuvwxyzabcdefghijklm",
+			"abcdefghijklmnopqrstuvwxyz")
+		return str.translate(self.string, rotation)
+
+	def vigenere(self, worm):
+		"""
+		Vigenere Cipher
+		Provide the key used to encrypt the string (worm).
+		"""
+		decrypted = []
+		for i, character in enumerate(self.string):
+			decrypted.append(
+				alpha[(ord[character] - ord[worm[i % len(worm)]]) % 26])
+		return "".join(decrypted)
+
+	def godel(self, n, prime=2):
+		"""
+		Gödel number
+		Specify a starting prime and the length of the string.
+		"""
+		decrypted = []
+		for i in primes.primes(prime, n):
+			character = -1
+			r, s = 0, self.numero
+			while s % i == 0:
+				r += 1
+				s //= i
+			decrypted.append(alpha[r - 1 % 26])
+		return "".join(decrypted)
+
+	def vernam(self, pad):
+		"""
+		Vernam Cipher
+		Provide the one-time-pad used to encrypt the string.
+		"""
+		encrypted = []
+		for i, character in enumerate(self.string):
+			encrypted.append(
+				alpha[(ord[character] - pad[i]) % 26])
+		return "".join(encrypted)

crypto/numbers.py

@@ -1,4 +1,6 @@
-import math, random, itertools
+import math
+import random
+import itertools
 import pyaudio
 
 opzioni = {
@@ -10,13 +12,13 @@ opzioni = {
 }
 
 
-class primi:
+class primes:
 
-	def primo(n, k=64):
+	def prime(n, k=64):
 		"""
-		Test di primalità probabilistico Miller-Rabin.
+		Probabilistic primality test Miller-Rabin.
-		Restituisce True se n è primo altrimenti restituisce False.
+		Return True if n is probably prime otherwise return False.
-		La probabilità che sia sbagliato è 2^-2k
+		The probability that it is wrong is 2^-2k
 		"""
 		if n < 2 or n % 2 == 0:
 			return False
@@ -41,10 +43,10 @@ class primi:
 				return False
 		return True
 
-	def primi(p, n):
+	def primes(p, n):
 		"""
-		Restituisce gli n numeri primi succesivi a p.
+		Returns the n primes subsequent p.
-		[Generatore]
+		[Generator]
 		"""
 		if p == 2:
 			n -= 1
@@ -55,36 +57,34 @@ class primi:
 		while True:
 			if i == n:
 				break
-			if primi.primo(p):
+			if primes.prime(p):
 				i += 1
 				yield p
 			p += 2
 
 
-class generatore:
+class generator:
 
-	def caso(inizio, fine, n):
+	def random(start, stop, n):
 		"""
-		Restituisce n interi casuali nell'intervallo [inizio; fine).
+		Returns n random integers in the range [start, end).
-		[Generatore]
+		[Generator]
 		"""
 		audio = pyaudio.PyAudio()
 		input = audio.open(**opzioni)
 		dati = input.read(
-			opzioni["rate"] //
+			opzioni["rate"] // opzioni["frames_per_buffer"] * 
-			opzioni["frames_per_buffer"] *
+			int(math.log(n)) + 500)
-			int(math.log(n)) + 500
-		)
 		input.close()
 		audio.terminate()
 		dati = [i for i in dati if i != 0]
-		dati = [i for i in dati if i in range(inizio, fine)]
+		dati = [i for i in dati if i in range(start, stop)]
 		random.shuffle(dati)
 		for i in range(n):
 			yield dati[i]
 
 	def onetimepad(l):
 		"""
-		Ritorna una l-tupla di interi casuali per un one-time-pad.
+		Return an l-uple of random integers for a one-time-pad.
 		"""
-		return tuple(generatore.caso(0, 2 * 16, l))
+		return tuple(generator.random(0, 2 * 16, l))

crypto/unicode.py

@@ -0,0 +1,115 @@
+from .numbers import *
+
+max = 2 ** 16
+
+
+class encrypt:
+
+	def __init__(self, value):
+		"""
+		Initialization
+		Provide a string to encrypt.
+		"""
+		self.string = value
+
+	def rot13(self):
+		"""
+		Cifrario ROT13
+		"""
+		rotation = str.maketrans(
+			"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
+			"nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM")
+		return str.translate(self.string, rotation)
+
+	def vigenere(self, worm):
+		"""
+		vigenère Chiper
+		Provide an alphabetical key length less than the string (worm).
+		"""
+		encrypted = []
+		for i, character in enumerate(self.string):
+			encrypted.append(
+				chr((ord(character) + ord(worm[i % len(worm)])) % max))
+		return "".join(encrypted)
+
+	def godel(self, prime=2):
+		"""
+		Gödel number
+		Provide a prime.
+		"""
+		encrypted = 1
+		sequence = primes.primes(prime, len(self.string))
+		for i, character in enumerate(self.string):
+			encrypted *= next(sequence) ** ord(character)
+		return encrypted
+
+	def vernam(self, pad=()):
+		"""
+		Vernam Cipher
+		A one-time-pad will be generated automatically if not provided.
+		"""
+		encrypted = []
+		if pad is ():
+			pad = generator.onetimepad(len(self.string))
+		for i, character in enumerate(self.string):
+			encrypted.append(
+				chr((ord(character) + pad[i]) % max))
+		return "".join(encrypted), pad
+
+
+class decrypt:
+
+	def __init__(self, value):
+		"""
+		Initialization
+		Provide a string or a number (Gödel) to decrypt.
+		"""
+		if str(value).isnumeric():
+			self.numero = value
+		else:
+			self.string = value
+
+	def rot13(self):
+		"""
+		ROT13 Cipher
+		"""
+		rotation = str.maketrans(
+			"nopqrstuvwxyzabcdefghijklmNOPQRSTUVWXYZABCDEFGHIJKLM",
+			"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
+		return str.translate(self.string, rotation)
+
+	def vigenere(self, worm):
+		"""
+		Vigenere Cipher
+		Provide the key used to encrypt the string (worm).
+		"""
+		decrypted = []
+		for i, character in enumerate(self.string):
+			decrypted.append(
+				chr((ord(character) - ord(worm[i % len(worm)])) % max))
+		return "".join(decrypted)
+
+	def godel(self, n, prime=2):
+		"""
+		Gödel number
+		Specify a starting prime and the length of the string.
+		"""
+		decrypted = []
+		for i in primes.primes(prime, n):
+			r, s = 0, self.numero
+			while s % i == 0:
+				r += 1
+				s //= i
+			decrypted.append(chr(r % max))
+		return "".join(decrypted)
+
+	def vernam(self, pad):
+		"""
+		Vernam Cipher
+		Provide the one-time-pad used to encrypt the string.
+		"""
+		encrypted = []
+		for i, character in enumerate(self.string):
+			encrypted.append(
+				chr((ord(character) - pad[i]) % max))
+		return "".join(encrypted)

example.py

@@ -0,0 +1,17 @@
+from crypto.unicode import encrypt, decrypt
+
+string = encrypt("Text to encrypt")
+a = string.rot13()
+b = string.vigenere(worm="worm")
+c = string.vernam()
+d = string.godel(prime=1117)
+
+print(a, b, c, d, sep="\n")
+
+a = decrypt(a).rot13()
+b = decrypt(b).vigenere(worm="worm")
+c = decrypt(c[0]).vernam(c[1])
+d = decrypt(d).godel(n=len(a), prime=1117)
+
+print(a, b, c, d, sep="\n")
+