# Zad 1. Stosując szyfr Cezara
# a) z przesunięciem 9 zaszyfruj słowo 

# funkcja do zamiany tekstu na liczby od 0 do 25 ( zamiana liter na kody ASCII i przesuniecie o 9)
def Text2Licz (t):
    return map( lambda x: ord(x) -65,t)

# funkcja odwrotna - do zamiany liczb na tekst
def Licz2Text (l):
    return "".join (map ( lambda x: chr(x +65) ,l))

liczby=Text2Licz('ZASTOSOWANIE') #zamiana napisu na ciag liczb
liczby

liczby_szyfr=[(x+9)%26 for x in liczby ] #zastosowanie szyfru Cezara
liczby_szyfr

Licz2Text(liczby_szyfr) #WYNIK szyfrowania

# b) odszyfruj słowo EIFIEQCOG zakodowane z przesunięciem 20

Licz2Text (liczby2) #WYNIK deszyfrowania
liczby_szyfr = Text2Licz ('EIFIEQCOG')
liczby2 = [(x -20) %26 for x in liczby_szyfr ] # odszyfrowanie (na liczbach ) przesunięcie o 20
Licz2Text ( liczby2 ) # WYNIK deszyfrowania

# c) (metodę brute force) odszyfruj napis VAKSTLSVSUKSFBPMKSVBGBX oraz znajdź wartość przesunięcia zastosowaną w szyfrowaniu.
# atak brute force :

C= Text2Licz ('VAKSTLSVSUKSFBPMKSVBGBX')
# wszystkie mozliwe kombinacje odkodowania zaszyfrowanego tekstu
for j in range (26) : print Licz2Text ([(x-j) %26 for x in C ])

# przesunięcie=19 napis=CHRZASZCZBRZMIWTRZCINIE

# Zad 2. Wygeneruj listę 10 liczb parzystych (od 0) w zapisie
# a) binarnym bez przedrostków
A=(0,2,4,6,8,10,12,14,16,18)
# zapis binarnym bez przedrostków
[ Integer(k*2).binary() for k in A]

# b) binarnym z przedrostkami
#binarne z przedrostkami
[bin(k) for k in A]

# c) szesnastkowym
[hex(k) for k in A]

# d) dziesiętnym
[k.digits(10) for k in A]

# e) o podstawie 4
[k.digits(4) for k in A]

# Zad 3. Zapisz liczbę szesnastkową abcd w postaci
# a) dziesiętnej
#dziesiętnej
Integer ('abcd' ,16)
# b) binarnej
#binarnej
Integer ('abcd' ,16).binary()

# Zad 4. Za pomocą kodowania base64
# a) zaszyfruj napis "Zarewolwerowany rewolwer"

#base64
import base64
base64.b64encode('Zarewolwerowany rewolwer')

# b) odszyfruj napis "TWF0a2EgdGthIGkgdGF0a2EgdGthLCBhIHRrYWN6a2EgY3prYSBpIHRleiB0YW0gdGthLg=="
# odkodowanie i sprawdzenie poprawnosci
base64 .b64decode ('TWF0a2EgdGthIGkgdGF0a2EgdGthLCBhIHRrYWN6a2EgY3prYSBpIHRleiB0YW0gdGthLg==') #odkodowywanie

# Zad 5. Oblicz skrot teksu "Zarewolwerowany rewolwer" korzystając z funkcji skrotu
# a) sha265 (wyświetl wynik w zapisie binarnym)
import hashlib
hashlib.sha265('Zarewolwerowany rewolwer').digest()
# b) sha512 (wyświetl wynik w zapisie szesnastkowym)
hashlib.sha512('Zarewolwerowany rewolwer').hexdigest()

# Zad 6. Wylosuj listę 10 elementow z grupy Z_25 i wylicz dla każdego jego element odwrotny jeśli istnieje (wyniki rowniez umiesc na liscie). Nastepnie sprawdz czy ich iloczyn w grupie Z_25 rzeczywiscie da 1.

A=[ randint (0, 25) for i in range (10) ]


# Zad 7. Wyznacz zbior elementow odwracalnych dla Z_12, oblicz jej rzad i wyznacz "tabelke mnozenia"

def zb_el_odwr(n):
    u=[k for k in range (1,n) if gcd(k,n)==1]
    return u

B=[zb_el_odw(k) for k in range A]
C =[k for k in range (B) if gcd(n,k) ==1]

def euler(n):
    u=zb_el_odwr(n)
    return len(u)

n=12
u=zb_el_odwr(n);u
euler(n)
matrix([[mod(k,n)*mod(l,n) for l in u] for k in u])

# Zad 8. Dla każdego elementu z grupy Z^*_18 oblicz jego rząd i wyznacz podgrupę cykliczną generowaną przez ten element.
def podgrupy(n):
    Znstar =[k for k in range (n) if gcd(n,k) ==1]
    Zn= Zmod (n)
    rz=euler_phi(n)
    l1 =[ uniq ([ Zn(x)^k for k in range (1 ,rz) ]) for x in Znstar ]
    return l1

Z18=Zmod(18)
Z18star=18.coprime_integers(18)#zbior elementow odwracalnych w Z_{15}
Z18star

euler_phi(18)#==moc Z15star

[Z18(x).multiplicative_order()for x in Z18star]#rzędy elementow

# Zad 9. Za pomoca znajdowania pierwiastków pierwotnych zbadaj, która z liczb 879, 883, 886 jest pierwsza. Zbadaj i napisz odpowiedzi dla każdej liczby.
def pierwsza(n):
    pp=primitive_root(n)
    r=multiplicative_order(Mod(pp,n))
    return r==n-1


pierwsza(879)
pierwsza(883)
pierwsza(886)

# Zad 10. Dla liczby pierwszej 0xD55F35EBCBEE8E190350ECA2C66AAC5471C1FF8FE99F2178212AD7CC55ADB34740F50F019EAD5115D6E02572A0A17770930C43929D203492572DEB0284AC681F792F759C58FBEB61FDA36C63DC7B6B70A5DC811237BE15C586E4796156E7E06D2EE16842FA3A67DAD4CC254566D59DCD3A8DE0EAE2BD5AE0F22BCC1C3416666F przeprowadź i opisz protokuł uzgadniania klucza Dieffie-Hellman.

p="0xD55F35EBCBEE8E190350ECA2C66AAC5471C1FF8FE99F2178212AD7CC55ADB34740F50F019EAD5115D6E02572A0A17770930C43929D203492572DEB0284AC681F792F759C58FBEB61FDA36C63DC7B6B70A5DC811237BE15C586E4796156E7E06D2EE16842FA3A67DAD4CC254566D59DCD3A8DE0EAE2BD5AE0F22BCC1C3416666F"

p=ZZ(p) # zamiana napisu na liczbe
# sprawdzenie czy p jest liczba pierwsza ( kilka sposobow )
is_pseudoprime (p)
is_prime (p)
r=primitive_root(p)
rp=mod(r,p) # rp: r jako element Z_p
multiplicative_order(rp)==p-1 # rzad rp w Z^* _p = p -1
# -----------------------------------------------------------
# protokul Diffie - Hellman uzgadniania klucza
# -----------------------------------------------------------
p # jawna liczba pierwsza p
r= primitive_root (p) # jawny pierwiastek pierwotny z p
# ----------- A --------------
j = randint (2,p -2) # tajna liczba z zakresu 2<= j <= p -2 (zna tylko A)
j # klucz prywatny A
a = power_mod (r,j,p) # jawna liczba a = r^j mod p
a # klucz publiczny przesylany do B
# ----------- B --------------
k = randint (2,p -2) # tajna liczba z zakresu 2<= k <= p -2 (zna tylko B)
k # klucz prywatny B
b = power_mod (r,k,p) # jawna liczba b = r^k mod p
b # klucz publiczny przesylany do A
# A sprawdza symbol Legendre ’a dla klucza publicznego b
pow (b ,(p -1) /2,p)==1
# A generuje klucz wspolny ( tajny ) na podstawie b i klucza prywatnego j
klucz = power_mod (b,j,p)
# to samo dla B
pow (a ,(p -1) /2,p)==1
# B generuje klucz wspolny ( tajny ) na podstawie a i klucza prywatnego k
klucz = power_mod (a,k,p)
# czy A i B wygenerowaly ten sam klucz wspolny ?
power_mod (a,k,p) == power_mod (b,j,p)
klucz
# wyliczenie klucza na podstawie kluczy prywatnych
klucz == power_mod (r,j*k,p)


























# Zad 11. Otrzymałeś wiadomość zakodowaną w systemie ElGamal: (6763976774864894207828393674779271937142062482625, 7296210157774614306865362895291162765155937717526). Odszyfruj ją. Twoje klucze to 19279925378618992601011664494988164396776235152136 oraz  (21004686380765859348200631283534141361634697092089, 3, 8952338390620200521588363416616820568609938968904)
c1=6763976774864894207828393674779271937142062482625
c2=7296210157774614306865362895291162765155937717526
k=19279925378618992601011664494988164396776235152136
(p,r,a)=(21004686380765859348200631283534141361634697092089, 3, 8952338390620200521588363416616820568609938968904)
# -----------------------------------------------------------
# Deszyfrowanie w systemie ElGamal
# -----------------------------------------------------------
# 1. Dla kazdego bloku obliczamy P = c2*c1 ^(p -1-k) mod p uzywajac klucza prywatnego k
c3 = [pow(c,p -1-k,p) for c in c1]
P = [( c2[i]* c3[i])%p for i in range (len (c1))]
P
# 2. Zamiana liczb na tekst i sklejenie blokow
tekst =""
for t in P:
tekst = tekst +" "+ long_to_bytes (t)
print tekst

# Zad 12. Wygeneruj 1024 bitowy klucz w systemie ElGamal i podpisz nim skrot wiadomości "Podpis elektroniczny". Następnie opisz proces weryfikacji podpisu i przeprowadź ją.
from Crypto .PublicKey import ElGamal
from Crypto import Random

losowe1 = Random .new ().read
kluczAli = ElGamal .generate (1024L, losowe1 )

︠6e552cd1-0d1d-4297-b9e0-2d293c9133ed︠
k1 = kluczAli .x
k1 

# Zadania do zrobienia w TERMINALU - napisz polecenia terminala za pomocą ktorych:

# Zad 13. Zakodujesz słowo "Kolokwium" szyfrem aes (wynik w pilku, w postaci base64) i odkodujesz je (wynik na konsoli).
#~$ echo "Kolokwium" | openssl enc -aes-256-cbc -a -out plik.enc
#~$ openssl enc -d -aes-256-cbc -a -in plik.enc

# Zad 14. Zapiszesz do pliku swoje imie i nazwisko, a następnie obliczysz skrot tego pliku (wynik na konsoli). Uzyj dowolnej funkcji skrotu dostepnej w openssl.
#~$ echo "Paulina Lipa"> w1.txt
# ~$ openssl sha256 w1.txt




# Zad 15. Wygenerujesz 512-bitowy parametr do protokołu Dieffiego-Hellmana z generatorem 2. Wynik zapisz w pliku, w postaci szesnastkowej, w 1-2 liniach, bez separatorow ":". Następnie sprawdź poprawność wygenerowanego parametru za pomocą funkcji w openssl.



sed 's/://g' <dh.txt >dh1.txt