rnhmjoj/crypto
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

English translation

Browse Source
This commit is contained in:
Rnhmjoj 2014-01-14 17:36:54 +01:00
parent e88bad83f8
commit c7a533d42c
11 changed files with 302 additions and 319 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
Esempio.py
View File

@ -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")

10
License.txt
View File

@ -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

55
README.md
View File

@ -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

3
crittografia/__init__.py
View File

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

126
crittografia/alfabeto.py
View File

@ -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)

124
crittografia/unicode.py
View File

@ -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)

3
crypto/__init__.py Normal file
View File

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

117
crypto/alpha.py Normal file
View File

@ -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)

42
crittografia/numeri.py → crypto/numbers.py
View File

@ -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))

115
crypto/unicode.py Normal file
View File

@ -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)

17
example.py Normal file
View File

@ -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")