diff --git a/Esempio.py b/Esempio.py deleted file mode 100644 index 36d49ad..0000000 --- a/Esempio.py +++ /dev/null @@ -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") diff --git a/License.txt b/License.txt deleted file mode 100644 index 740078f..0000000 --- a/License.txt +++ /dev/null @@ -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 \ No newline at end of file diff --git a/README.md b/README.md index 9956aa6..48eecb3 100644 --- a/README.md +++ b/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 -Una raccolta di cifrari storici e famosi in python 3. -Per ora contiene: +### Info +A collection of historical and famous ciphers in python 3. +For now it contains: * ROT13; -* Cifrario di Vigenère; -* Cifrario di Vernam -* Numero di Gödel +* Vigenere cipher; +* Vernam cipher +* 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/). - -### Istruzioni -Codifica: +### Instruction +Encryption: - *.rot13(stringa): stringa da codificare; - *.vigenère(stringa,verme): stringa da codificare e verme(chiave di codifica); - *.vernam(stringa): stringa da codificare; - *.gödel(stringa,primo): stringa da codificare e un numero primo(è consigliabile di alcune migliaia di cifre); + *.rot13(string): string to be encoded; + *.vigenere(string, worm): string to encode and worm (encryption key); + *.vernam(string): string to be encoded; + *.godel(string, first): string to be encoded and a prime number (a few thousand digits are recommended); +Decryption: -Decodifica: - - *.rot13(stringa): stringa codificata; - *.vigenère(stringa,verme): stringa codificata e verme(chiave di codifica); - *.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; - -### Utilizzo -Nel file "Esempio.py" c'è un esempio di utilizzo di ogni funzione. + *.rot13(string): encoded string; + *.vigenere(string, worm) encoded string and worm (encryption key); + *.vernam(string, pad): encoded string and onetimepad in a tuple; + *.godel(string, first, n): encoded string, number and length of the first decoded string; + +### Usage +In "example.py" there is an example of the use of each function. + +### License +Dual licensed under the MIT and GPL licenses: +http://www.opensource.org/licenses/mit-license.php +http://www.gnu.org/licenses/gpl.html diff --git a/crittografia/__init__.py b/crittografia/__init__.py deleted file mode 100644 index 23c3a28..0000000 --- a/crittografia/__init__.py +++ /dev/null @@ -1,3 +0,0 @@ -from .alfabeto import * -from .unicode import * -from .numeri import * diff --git a/crittografia/alfabeto.py b/crittografia/alfabeto.py deleted file mode 100644 index 8ca5924..0000000 --- a/crittografia/alfabeto.py +++ /dev/null @@ -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) diff --git a/crittografia/unicode.py b/crittografia/unicode.py deleted file mode 100644 index 94fcc05..0000000 --- a/crittografia/unicode.py +++ /dev/null @@ -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) diff --git a/crypto/__init__.py b/crypto/__init__.py new file mode 100644 index 0000000..b7343aa --- /dev/null +++ b/crypto/__init__.py @@ -0,0 +1,3 @@ +from .alpha import * +from .unicode import * +from .numbers import * diff --git a/crypto/alpha.py b/crypto/alpha.py new file mode 100644 index 0000000..8b7c648 --- /dev/null +++ b/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) diff --git a/crittografia/numeri.py b/crypto/numbers.py similarity index 57% rename from crittografia/numeri.py rename to crypto/numbers.py index f126bbf..eebe5fc 100644 --- a/crittografia/numeri.py +++ b/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. - Restituisce True se n è primo altrimenti restituisce False. - La probabilità che sia sbagliato è 2^-2k + Probabilistic primality test Miller-Rabin. + Return True if n is probably prime otherwise return False. + 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. - [Generatore] + Returns the n primes subsequent p. + [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). - [Generatore] + Returns n random integers in the range [start, end). + [Generator] """ audio = pyaudio.PyAudio() input = audio.open(**opzioni) dati = input.read( - opzioni["rate"] // - opzioni["frames_per_buffer"] * - int(math.log(n)) + 500 - ) + opzioni["rate"] // opzioni["frames_per_buffer"] * + 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)) diff --git a/crypto/unicode.py b/crypto/unicode.py new file mode 100644 index 0000000..16d6f62 --- /dev/null +++ b/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) diff --git a/example.py b/example.py new file mode 100644 index 0000000..68b2615 --- /dev/null +++ b/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") +