def test_mac_vectors(self):
k1, k2 = _mac_ks(self.ciph.encrypt, 8)
self.assertSequenceEqual(hexenc(k1), "5f459b3342521424")
self.assertSequenceEqual(hexenc(k2), "be8b366684a42848")
self.assertSequenceEqual(
hexenc(mac(self.ciph.encrypt, 8, hexdec(self.plaintext))[:4]),
"154e7210",
)
def test_mac_vectors(self):
k1, k2 = _mac_ks(self.ciph.encrypt, 16)
self.assertSequenceEqual(hexenc(k1),
"297d82bc4d39e3ca0de0573298151dc7")
self.assertSequenceEqual(hexenc(k2),
"52fb05789a73c7941bc0ae65302a3b8e")
self.assertSequenceEqual(
hexenc(mac(self.ciph.encrypt, 16, hexdec(self.plaintext))[:8]),
"336f4d296059fbe3",
)
def test_ecb_vectors(self):
ciphtext = ""
ciphtext += "7f679d90bebc24305a468d42b9d4edcd"
ciphtext += "b429912c6e0032f9285452d76718d08b"
ciphtext += "f0ca33549d247ceef3f5a5313bd4b157"
ciphtext += "d0b09ccde830b9eb3a02c4c5aa8ada98"
self.assertSequenceEqual(
hexenc(ecb_encrypt(self.ciph.encrypt, 16, hexdec(self.plaintext))),
ciphtext,
)
self.assertSequenceEqual(
hexenc(ecb_decrypt(self.ciph.decrypt, 16, hexdec(ciphtext))),
self.plaintext,
)
def test_ecb_vectors(self):
ciphtext = ""
ciphtext += "2b073f0494f372a0"
ciphtext += "de70e715d3556e48"
ciphtext += "11d8d9e9eacfbc1e"
ciphtext += "7c68260996c67efb"
self.assertSequenceEqual(
hexenc(ecb_encrypt(self.ciph.encrypt, 8, hexdec(self.plaintext))),
ciphtext,
)
self.assertSequenceEqual(
hexenc(ecb_decrypt(self.ciph.decrypt, 8, hexdec(ciphtext))),
self.plaintext,
)
def test_ofb_vectors(self):
iv = self.iv[:16]
ciphtext = ""
ciphtext += "db37e0e266903c83"
ciphtext += "0d46644c1f9a089c"
ciphtext += "a0f83062430e327e"
ciphtext += "c824efb8bd4fdb05"
self.assertSequenceEqual(
hexenc(ofb(self.ciph.encrypt, 8, hexdec(self.plaintext), iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(ofb(self.ciph.encrypt, 8, hexdec(ciphtext), iv)),
self.plaintext,
)
def test_ctr_vectors(self):
ciphtext = ""
ciphtext += "4e98110c97b7b93c"
ciphtext += "3e250d93d6e85d69"
ciphtext += "136d868807b2dbef"
ciphtext += "568eb680ab52a12d"
iv = self.iv[:4]
self.assertSequenceEqual(
hexenc(ctr(self.ciph.encrypt, 8, hexdec(self.plaintext), iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(ctr(self.ciph.encrypt, 8, hexdec(ciphtext), iv)),
self.plaintext,
)
def test_ctr_vectors(self):
ciphtext = ""
ciphtext += "f195d8bec10ed1dbd57b5fa240bda1b8"
ciphtext += "85eee733f6a13e5df33ce4b33c45dee4"
ciphtext += "a5eae88be6356ed3d5e877f13564a3a5"
ciphtext += "cb91fab1f20cbab6d1c6d15820bdba73"
iv = self.iv[:8]
self.assertSequenceEqual(
hexenc(ctr(self.ciph.encrypt, 16, hexdec(self.plaintext), iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(ctr(self.ciph.encrypt, 16, hexdec(ciphtext), iv)),
self.plaintext,
)
def test_ofb_vectors(self):
ciphtext = ""
ciphtext += "81800a59b1842b24ff1f795e897abd95"
ciphtext += "ed5b47a7048cfab48fb521369d9326bf"
ciphtext += "66a257ac3ca0b8b1c80fe7fc10288a13"
ciphtext += "203ebbc066138660a0292243f6903150"
self.assertSequenceEqual(
hexenc(ofb(self.ciph.encrypt, 16, hexdec(self.plaintext),
self.iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(ofb(self.ciph.encrypt, 16, hexdec(ciphtext), self.iv)),
self.plaintext,
)
def test_cfb_vectors(self):
iv = self.iv[:16]
ciphtext = ""
ciphtext += "db37e0e266903c83"
ciphtext += "0d46644c1f9a089c"
ciphtext += "24bdd2035315d38b"
ciphtext += "bcc0321421075505"
self.assertSequenceEqual(
hexenc(
cfb_encrypt(self.ciph.encrypt, 8, hexdec(self.plaintext), iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(cfb_decrypt(self.ciph.encrypt, 8, hexdec(ciphtext), iv)),
self.plaintext,
)
def form_valid(self, form):
form.instance.author = self.request.user
form.instance.date = timezone.now()
form.instance.is_closed = False
if not form.instance.title:
form.instance.title = form.instance.text[:min(len(form.instance.text),20)] + '...'
gost3411 = GOST34112012256()
gost3411.update(str(form.instance.author).encode())
gost3411.update(str(form.instance.date).encode())
gost3411.update(str(form.instance.text).encode())
form.instance.order_hash = hexenc(gost3411.digest())
self.object = form.save()
check_users = self.request.POST.getlist('check_users')
for user_id in check_users:
self.user_order_save(User.objects.get(pk=user_id))
check_groups = self.request.POST.getlist('check_groups')
for group_id in check_groups:
for user in User.objects.filter(pmembers__id=group_id):
self.user_order_save(user)
self.signer_save(self.request.user)
check_susers = self.request.POST.getlist('check_susers')
for user_id in check_susers:
self.signer_save(User.objects.get(pk=user_id))
check_sgroups = self.request.POST.getlist('check_sgroups')
for group_id in check_sgroups:
for user in User.objects.filter(pmembers__id=group_id):
self.signer_save(user)
return HttpResponseRedirect(self.get_success_url())
def test_2(self):
"""Test vector from 34.10-2012 standard itself
"""
curve = GOST3410Curve(
p=
3623986102229003635907788753683874306021320925534678605086546150450856166624002482588482022271496854025090823603058735163734263822371964987228582907372403,
q=
3623986102229003635907788753683874306021320925534678605086546150450856166623969164898305032863068499961404079437936585455865192212970734808812618120619743,
a=7,
b=
1518655069210828534508950034714043154928747527740206436194018823352809982443793732829756914785974674866041605397883677596626326413990136959047435811826396,
x=
1928356944067022849399309401243137598997786635459507974357075491307766592685835441065557681003184874819658004903212332884252335830250729527632383493573274,
y=
2288728693371972859970012155529478416353562327329506180314497425931102860301572814141997072271708807066593850650334152381857347798885864807605098724013854,
)
prv = bytes2long(
hexdec(
"0BA6048AADAE241BA40936D47756D7C93091A0E8514669700EE7508E508B102072E8123B2200A0563322DAD2827E2714A2636B7BFD18AADFC62967821FA18DD4"
))
digest = hexdec(
"3754F3CFACC9E0615C4F4A7C4D8DAB531B09B6F9C170C533A71D147035B0C5917184EE536593F4414339976C647C5D5A407ADEDB1D560C4FC6777D2972075B8C"
)
rand = hexdec(
"0359E7F4B1410FEACC570456C6801496946312120B39D019D455986E364F365886748ED7A44B3E794434006011842286212273A6D14CF70EA3AF71BB1AE679F1"
)
signature = sign(curve, prv, digest, rand, mode=2012)
r = "2f86fa60a081091a23dd795e1e3c689ee512a3c82ee0dcc2643c78eea8fcacd35492558486b20f1c9ec197c90699850260c93bcbcd9c5c3317e19344e173ae36"
s = "1081b394696ffe8e6585e7a9362d26b6325f56778aadbc081c0bfbe933d52ff5823ce288e8c4f362526080df7f70ce406a6eeb1f56919cb92a9853bde73e5b4a"
self.assertSequenceEqual(hexenc(signature), s + r)
def test_cbc_vectors(self):
ciphtext = ""
ciphtext += "689972d4a085fa4d90e52e3d6d7dcc27"
ciphtext += "2826e661b478eca6af1e8e448d5ea5ac"
ciphtext += "fe7babf1e91999e85640e8b0f49d90d0"
ciphtext += "167688065a895c631a2d9a1560b63970"
self.assertSequenceEqual(
hexenc(
cbc_encrypt(self.ciph.encrypt, 16, hexdec(self.plaintext),
self.iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(
cbc_decrypt(self.ciph.decrypt, 16, hexdec(ciphtext), self.iv)),
self.plaintext,
)
def test_cfb_vectors(self):
ciphtext = ""
ciphtext += "81800a59b1842b24ff1f795e897abd95"
ciphtext += "ed5b47a7048cfab48fb521369d9326bf"
ciphtext += "79f2a8eb5cc68d38842d264e97a238b5"
ciphtext += "4ffebecd4e922de6c75bd9dd44fbf4d1"
self.assertSequenceEqual(
hexenc(
cfb_encrypt(self.ciph.encrypt, 16, hexdec(self.plaintext),
self.iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(
cfb_decrypt(self.ciph.encrypt, 16, hexdec(ciphtext), self.iv)),
self.plaintext,
)
def test_cbc_vectors(self):
ciphtext = ""
ciphtext += "96d1b05eea683919"
ciphtext += "aff76129abb937b9"
ciphtext += "5058b4a1c4bc0019"
ciphtext += "20b78b1a7cd7e667"
self.assertSequenceEqual(
hexenc(
cbc_encrypt(self.ciph.encrypt, 8, hexdec(self.plaintext),
self.iv)),
ciphtext,
)
self.assertSequenceEqual(
hexenc(cbc_decrypt(self.ciph.decrypt, 8, hexdec(ciphtext),
self.iv)),
self.plaintext,
)
def test_5(self):
self.assertSequenceEqual(
hexenc(pbkdf2(
b"passwordPASSWORDpassword",
b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
4096,
40,
)),
"788358c69cb2dbe251a7bb17d5f4241f265a792a35becde8d56f326b49c85047b7638acb4764b1fd",
)
def test_6(self):
self.assertEqual(
hexenc(pbkdf2(
b"pass\x00word",
b"sa\x00lt",
4096,
20,
)),
"43e06c5590b08c0225242373127edf9c8e9c3291",
)
def test_5(self):
self.assertEqual(
hexenc(
pbkdf2(
b"passwordPASSWORDpassword",
b"saltSALTsaltSALTsaltSALTsaltSALTsalt",
4096,
100,
)),
"b2d8f1245fc4d29274802057e4b54e0a0753aa22fc53760b301cf008679e58fe4bee9addcae99ba2b0b20f431a9c5e50f395c89387d0945aedeca6eb4015dfc2bd2421ee9bb71183ba882ceebfef259f33f9e27dc6178cb89dc37428cf9cc52a2baa2d3a",
)
def test_1(self):
"""Test vector from 34.10-2012 standard itself
"""
curve = CURVES["id-GostR3410-2001-TestParamSet"]
prv = bytes2long(
hexdec(
"7A929ADE789BB9BE10ED359DD39A72C11B60961F49397EEE1D19CE9891EC3B28"
))
digest = hexdec(
"2DFBC1B372D89A1188C09C52E0EEC61FCE52032AB1022E8E67ECE6672B043EE5")
rand = hexdec(
"77105C9B20BCD3122823C8CF6FCC7B956DE33814E95B7FE64FED924594DCEAB3")
signature = sign(curve, prv, digest, rand)
r = "41aa28d2f1ab148280cd9ed56feda41974053554a42767b83ad043fd39dc0493"
s = "01456c64ba4642a1653c235a98a60249bcd6d3f746b631df928014f6c5bf9c40"
self.assertSequenceEqual(hexenc(signature), s + r)
def digest(self):
""" Get hash of the provided data
"""
l = 0
checksum = 0
h = 32 * b'\x00'
m = self.data
for i in xrange(0, len(m), BLOCKSIZE):
part = m[i:i + BLOCKSIZE][::-1]
l += len(part) * 8
checksum = addmod(checksum, int(hexenc(part), 16), 2 ** 256)
if len(part) < BLOCKSIZE:
part = b'\x00' * (BLOCKSIZE - len(part)) + part
h = _step(h, part, self.sbox)
h = _step(h, 24 * b'\x00' + pack(">Q", l), self.sbox)
checksum = hex(checksum)[2:].rstrip("L")
if len(checksum) % 2 != 0:
checksum = "0" + checksum
checksum = hexdec(checksum)
checksum = b'\x00' * (BLOCKSIZE - len(checksum)) + checksum
h = _step(h, checksum, self.sbox)
return h
def digest(self):
""" Get hash of the provided data
"""
_len = 0
checksum = 0
h = 32 * b"\x00"
m = self.data
for i in xrange(0, len(m), BLOCKSIZE):
part = m[i:i + BLOCKSIZE][::-1]
_len += len(part) * 8
checksum = addmod(checksum, int(hexenc(part), 16), 2 ** 256)
if len(part) < BLOCKSIZE:
part = b"\x00" * (BLOCKSIZE - len(part)) + part
h = _step(h, part, self.sbox)
h = _step(h, 24 * b"\x00" + pack(">Q", _len), self.sbox)
checksum = hex(checksum)[2:].rstrip("L")
if len(checksum) % 2 != 0:
checksum = "0" + checksum
checksum = hexdec(checksum)
checksum = b"\x00" * (BLOCKSIZE - len(checksum)) + checksum
h = _step(h, checksum, self.sbox)
return h[::-1]
def hexdigest(self):
"""Return the hash value as a string containing hexadecimal digits.
"""
return hexenc(self.digest())
def test_6(self):
self.assertEqual(
hexenc(pbkdf2(b"pass\x00word", b"sa\x00lt", 4096, 64)),
"50df062885b69801a3c10248eb0a27ab6e522ffeb20c991c660f001475d73a4e167f782c18e97e92976d9c1d970831ea78ccb879f67068cdac1910740844e830",
)
from gost import *
#gost.py es parte de la libreria, pero solo el archivo.
#como es un standar ruso, gran parte de lo que encontré en internet
#estaba en ese idioma así que el camino más corto fue ver directamente
#la implementación del algoritmo y ver como usarlo
#el resto de funciones de pygost son para codificar y decodificar entre arreglos de bytes y hexadecimal
from functools import partial
from pygost.utils import hexdec
from pygost.utils import strxor
from pygost.utils import xrange
from pygost.utils import hexenc
#pip instal pygost
#ejecutar con python3 tarea3.py
pt = hexdec("holaaaaa".encode("utf-8").hex())
key = hexdec("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".encode("utf-8").hex())
ct = ecb_encrypt(key, pt)
#dt = ecb_encrypt(key, ct)
print('mensaje en texto plano: ' + hexenc(pt))
print('mensaje encriptado: ' + hexenc(ct))
#print(hexenc(dt))
html = """
<p>Mensaje secreto</p>
<div class='kuznyechik' id='""" + hexenc(ct) + """'></div>
"""
file = open("index.html", "w")
file.write(html)
file.close()
def test_4(self):
self.assertEqual(
hexenc(pbkdf2(b"password", b"salt", 1677216, 64)),
"49e4843bba76e300afe24c4d23dc7392def12f2c0e244172367cd70a8982ac361adb601c7e2a314e8cb7b1e9df840e36ab5615be5d742b6cf203fb55fdc48071",
)
def to_string(self, pub=False):
if pub:
return hexenc(pub_marshal(self.pub))
return self.prv
def test_ecb_symmetric(self):
for _ in range(100):
pt = pad2(urandom(randint(0, 16 * 2)), 16)
ciph = GOST3412Kuznechik(urandom(32))
ct = ecb_encrypt(ciph.encrypt, 16, pt)
dt = ecb_decrypt(ciph.decrypt, 16, ct)
print(hexenc(self.key))
#print(hexenc(dt))
'''
'''
key = ""
key += "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"
s = key.encode("utf-8").hex()
ciph = GOST3412Kuznechik(hexdec(s))
#print(s)
plaintext = ""
plaintext += "holaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".encode("utf-8").hex()
texto_enc = hexenc(ecb_encrypt(ciph.encrypt, 16, hexdec(plaintext)))
texto_dec = hexenc(ecb_decrypt(ciph.decrypt, 16, hexdec(texto_enc)))
print(plaintext)
print(texto_enc)
print(texto_dec)
'''
pt = hexdec("holaaaaaaaaaaaaaaaaaaaaaaaaaaaaa".encode("utf-8").hex())
ciph = GOST3412Kuznechik(urandom(32))
ct = ecb_encrypt(ciph.encrypt, 16, pt)
dt = ecb_decrypt(ciph.decrypt, 16, ct)
print(hexenc(pt))
print(hexenc(ct))
print(hexenc(dt))
def test_4(self):
self.assertEqual(
hexenc(pbkdf2(b"password", b"salt", 16777216, 32)),
"a57ae5a6088396d120850c5c09de0a525100938a59b1b5c3f7810910d05fcd97",
)
def test_3(self):
self.assertEqual(
hexenc(pbkdf2(b"password", b"salt", 4096, 32)),
"1f1829a94bdff5be10d0aeb36af498e7a97467f3b31116a5a7c1afff9deadafe",
)
def test_2(self):
self.assertEqual(
hexenc(pbkdf2(b"password", b"salt", 2, 32)),
"990dfa2bd965639ba48b07b792775df79f2db34fef25f274378872fed7ed1bb3",
)
def test_1(self):
self.assertEqual(
hexenc(pbkdf2(b"password", b"salt", 1, 32)),
"7314e7c04fb2e662c543674253f68bd0b73445d07f241bed872882da21662d58",
)
def hexdigest(self):
return hexenc(self.digest())
