— Гость (27/11/2013 02:53)   

несколько примеров достойной реализации криптографического софта на Python

Рудиментарная поддержка PGP интегрируется в движки, используемые на pgpru.com, причём очередной новый движок будет как раз на Python.

— unknown (27/11/2013 09:32)   
KeccaK in Python^[link1], PyOpenSSL^[link2].

— Гость (27/11/2013 13:55)   
В Perl для стандартных криптографических библиотек openssl, mcrypt и т.п. (написанных на Си) как правило имеются модули реализующие доступ к ним из Perl. Поэтому в разработке новых библиотек нет особой необходимости. Python тоже скриптовый язык, и скорей всего в нём тоже уже созданы интерфейсы доступа к стандартным С-библиотекам.

— SATtva (27/11/2013 14:01)   
PyOpenSSL одна из них. Множество стандартных примитивов реализованы в PyCrypto. Если нужно что-то более экзотическое (ECC на Curve25519, к примеру), всё это ищется на https://pypi.python.org.

— Гость (27/11/2013 17:40)   
Я не очень пока понимаю – как подключать, точнее как работать с криптографическими библиотеками, поэтому и хочу посмотреть живой пример достойной реализации. К примеру:
from Crypto.Cipher import AES import base64 import os # размер блока шифрования BLOCK_SIZE = 32 # функция дополнения pad = lambda s: s + (BLOCK_SIZE - len(s) % BLOCK_SIZE) * PADDING # функции шифрования и расшифрования # результат дополнительно обертывается в base64 EncodeAES = lambda c, s: base64.b64encode(c.encrypt(pad(s))) DecodeAES = lambda c, e: c.decrypt(base64.b64decode(e)).rstrip(PADDING) # генерируем ключ secret = os.urandom(BLOCK_SIZE) # создаем объект cipher = AES.new(secret) # шифруем строку encoded = EncodeAES(cipher, 'password') print 'Encrypted string:', encoded # расшифровываем строку decoded = DecodeAES(cipher, encoded) print 'Decrypted string:', decoded

Откуда взялась переменная PADDING и почему на нее размер блоков умножается, где именно документация по поводу всех этих лямбд:
EncodeAES = lambda c, s: base64.b64encode(c.encrypt(pad(s)))
DecodeAES = lambda c, e: c.decrypt(base64.b64decode(e)).rstrip(PADDING)
Как мне сюда прикрепить всякие f.open или хотябы полноценную работу из консоли с указанием файлов?
Ну и много других вопросов. Я наверное логику не понимаю, да?
И еще – здесь без математики сильно печально будет да?

— unknown (27/11/2013 17:58, исправлен 27/11/2013 17:58)   

А это ковыряйте саму библиотеку.

А это уж как реализовано^[link3], опять же внутри этой либы.

А она даже и не нужна, вам только свои данные подставить в готовый синтаксис, или опять же смотрите в исходную либу.

Ну это уже нужен просто какой-нибудь мануал по стандартному синтаксису и функциям Python и ваша фантазия.

— Гость (27/11/2013 18:21)   
Вот я и хочу на практике это все понять, потому, что не совсем понимаю логику работы.

— SATtva (27/11/2013 19:02)   

Как мне сюда прикрепить всякие f.open или хотябы полноценную работу из консоли с указанием файлов?

Вы уверены, что достаточно владеете питоном? Пройдитесь, например, по Dive into Python, прежде чем лезть в криптографию.

Если очень интересна конкретика, вот низкоуровневый криптографический модуль из нового движка сайта, ковыряйте, он достаточно подробно документирован (реализован AES-CTR, RSA и ряд вспомогательных примитивов). Сходу он отдельно работать не будет из-за внешних зависимостей (paw и exc), отвязку оставляю упражнением для читателя.

# -*- coding: utf-8 -*- ''' PAWe cryptographic functions @copyright: 2013 Vlad "SATtva" Miller, http://vladmiller.info @license: GNU GPL, see COPYING for details. ''' from time import time as time_float from Crypto import Random from Crypto.Cipher import AES, PKCS1_OAEP from Crypto.PublicKey import RSA #from Crypto.Signature import PKCS1_PSS # TODO: Message signing if necessary. from Crypto.Util import Counter from pbkdf2 import PBKDF2 import base64, struct, hashlib, hmac as _hmac import paw from . import exc __all__ = ['uuid', 'random', 'hash', 'hmac', 'kdf', 'encrypt', 'decrypt', 'fingerprint', 'gen_pk', 'encrypt_pk', 'decrypt_pk'] RANDOM = Random.new() HASH = hashlib.sha512 MAC = _hmac CIPHER = AES PK_ENC = PKCS1_OAEP #PK_SIG = PKCS1_PSS # TODO: Message signing if deemed necessary. PACKAGE_SYM = 0 # A symmetrically encrypted data package. PACKAGE_PK = 1 # A public key encrypted data package. PK_CAP_ENCRYPT = 0 # Keypair with encryption capability. PK_CAP_SIGN = 1 # Keypair with signing capability. UUID_SIZE = 48 # Bytes. Will be base64-encoded into 64-byte string. KEY_SIZE = int(256 / 8) PUBKEY_SIZE = 2048 # In bits. KDF_ITER = 100 DELIM = b'|' # Delimiter for concatenated fields. ENCRYPT_KEY_DERIV = b'encrypt' MAC_KEY_DERIV = b'authenticate' ############################################################################### # Utility functions. ############################################################################### def concat(list): '''Concatenate a list of str/bytes into a delimeted string of bytes.''' encode = lambda val: val.encode() if isinstance(val, str) else val return DELIM.join([encode(item) for item in list if item is not None]) def time_bytes(): '''Return UNIX time float as a packed 8-byte string.''' i, _, j = str(time_float()).partition('.') return struct.pack('>II', int(i), int(j)) def random(size=KEY_SIZE, encode=None): ''' Return N random bytes from the Fortuna RNG. The output is encrypted with a random key derived from a short-term app secret to mask potential bias introduced in the real server environment. 'encode' argument can be any base64 encode function prefix (e.g. 'b16' or 'b64'), and defines the encoding applied to the output if necessary. ''' key = kdf(paw.CONTEXT['rnd'], time_bytes(), iter=1)[0] ctr, _ = counter() rnd = RANDOM.read(int(size)) output = _encrypt_plain(rnd, key, ctr) if encode: func = getattr(base64, encode + 'encode') output = func(output).decode().lower() return output def uuid(path): '''Generate object's 64-byte UUID (str).''' if not __debug__: rnd, host, salt = random(), '|'.join(paw.CONTEXT['host']), None else: rnd, host, salt = b'0', 'localhost', b'0' key = concat([rnd, host, path]) return base64.urlsafe_b64encode(kdf(key, salt=salt, size=UUID_SIZE)[0]).decode() def hash(data, hex=False): '''Return a hash of input data.''' output = HASH(data) return output.digest() if not hex else output.hexdigest() def hmac(data, key, hex=False): '''Generate HMAC for a given message and key.''' output = MAC.new(key, data, HASH) return output.digest() if not hex else output.hexdigest() def kdf(pwd, salt=None, size=KEY_SIZE, iter=KDF_ITER, hex=False): '''Return (key, salt, iter) for a PBKDF2(pwd).''' if not salt: salt = random() func = PBKDF2(pwd, salt, iter, digestmodule=HASH, macmodule=MAC) key = func.read(int(size)) return (key if not hex else base64.b16encode(key).lower(), salt, iter) ############################################################################### # Symmetric encryption functions. ############################################################################### def counter(nonce=None): ''' Initialize a new CTR mode counter object. Return (ctr, nonce), where 'ctr' is the counter object itself, and 'nonce' is a counter prefix. If nonce isn't provided as a function argument, a new one is used as 64-bit timer output. Note: The whole counter including nonce must be the length of a cipher block. E.g. for AES this means the counter is limited to 64 bits, which is deemed more than enough for the purposes of this application. ''' if not nonce: nonce = time_bytes() # 8 bytes aka 64 bits. # NB: Counter documentation is incorrect in regard to 'allow_wraparound' # argument which in fact is False by default and *will* throw an # exception when the counter wraps around. ctr = Counter.new((CIPHER.block_size - len(nonce)) * 8, prefix=nonce) return (ctr, nonce) def _encrypt_plain(msg, key, ctr): '''Encrypt a message with a given key and counter. For internal use only.''' return CIPHER.new(key, mode=CIPHER.MODE_CTR, counter=ctr).encrypt(msg) def _decrypt_plain(data, key, ctr): '''Decrypt a message with a given key and counter. For internal use only.''' return CIPHER.new(key, mode=CIPHER.MODE_CTR, counter=ctr).decrypt(data) def _derive_keys(key): '''Return a tuple of two separate keys for encryption and MAC operations.''' return (kdf(key, deriv, iter=1)[0] for deriv in [ENCRYPT_KEY_DERIV, MAC_KEY_DERIV]) def encrypt(msg, key, header=None): ''' Encrypt and MAC a message with a given key. MAC is calculated over the concatenated plaintext header (optional, doesn't gets encrypted), nonce (CTR prefix), and ciphertext. Separate keys are KDFed for encryption and MAC operations. Returns a tuple of (pkg_type, MAC, header, nonce, ciphertext, is_str). The first field is a PACKAGE_SYM constant. The 'header' field is a plaintext header. The 'is_str' field is a boolean value defining whether input message was str or bytes type. ''' if len(key) != KEY_SIZE: raise exc.CryptoKeyError('{}b key is provided, {}b is required'. format(len(key), KEY_SIZE)) ctr, nonce = counter() e_key, m_key = _derive_keys(key) ciphertext = _encrypt_plain(msg, e_key, ctr) mac = hmac(concat([header, nonce, ciphertext]), m_key) return (PACKAGE_SYM, mac, header, nonce, ciphertext, isinstance(msg, str)) def decrypt(package, key): ''' Decrypt a package with a given key. The 'package' is expected to be the same data structure as returned by the encrypt() function. First the package is decrypted, then MAC is checked, and if integrity is intact the plaintext data is returned. Returns a tuple containing the plaintext header (or None if absent) and the decrypted plaintext as the original data type (either str or bytes). In case of MAC mismatch raises CryptoMACError exception. If the data package provided for decryption is of wrong type (e.g. a PK-encrypted one), CryptoPkgTypeError exception is raised. ''' if package[0] is not PACKAGE_SYM: raise exc.CryptoPkgTypeError( 'wrong package type provided for decryption') _, mac, header, nonce, ciphertext, is_str = package ctr, _ = counter(nonce) e_key, m_key = _derive_keys(key) # Decrypt first, check MAC later to not facilitate side-channel attacks. plaintext = _decrypt_plain(ciphertext, e_key, ctr) if mac != hmac(concat([header, nonce, ciphertext]), m_key): raise exc.CryptoMACError('MAC validation failed') if is_str: plaintext = plaintext.decode() return (header, plaintext) ############################################################################### # Public key functions. ############################################################################### def fingerprint(pk, created): '''Return fingerprint (hash) of creation date and a public key component.''' if pk.has_private(): pk = pk.publickey() return hash(concat([str(created), pk.exportKey('DER')]), True) def gen_pk(capabilities): ''' Generate new RSA key pair(s). Function argument is either a single value or a list of key capabilities (PK_CAP_* constants), a separate keypair will be generated for each of them. Return a dict containter with the following structure: { PK_CAP: ( RSA_keypair, created_time, fingerprint ) } where 'created_time' is a UNIX timestamp (float), and 'fingerprint' is fingerprint() output. TODO: Make threaded. At least multiple keys should be generated in parallel. ''' if not isinstance(capabilities, list): capabilities = [capabilities] keys = {} for cap in capabilities: key = RSA.generate(PUBKEY_SIZE, random) created = time_float() keys[cap] = (key, created) return keys def encrypt_pk(msg, pk_keys, header=None): ''' Encrypt a message with a public key or a list of keys. The function employs a hybrid approach. First, a random symmetric key is generated which then is piped into encrypt() function along with the original message and an optional header. Second, the symmetric key is encrypted for each public key. Public keys must be provided in dict containters as output by gen_pk() function; all keys must have PK_CAP_ENCRYPT capability, otherwise CryptoPKCapabilityError is raised. Return a tuple with the following structure: ( pkg_type, { PK1_FP: enc1_key, PK2_FP: enc2_key, ... }, package ) where 'pkg_type' is a PACKAGE_PK constant, and 'package' is the original output of encrypt() function. The dict is constructed of PK fingerprints and the corresponding PK-encrypted symmetric key. TODO: Make threaded. Symmetric encryption and all asymmetric operations could be performed in parallel (needs benchmarking). ''' if not isinstance(pk_keys, list): pk_keys = [pk_keys] secret_key = random() package = encrypt(msg, secret_key, header) encrypted_keys = {} for pk_key in pk_keys: try: key, created = pk_key[PK_CAP_ENCRYPT] if not key.can_encrypt(): raise KeyError except KeyError: raise exc.CryptoPKCapabilityError('incompatible PK capabilities') fp = fingerprint(key, created) encrypted_keys[fp] = PK_ENC.new(key).encrypt(secret_key) return (PACKAGE_PK, encrypted_keys, package) def decrypt_pk(package, pk_key): ''' Decrypt a package with a given private key. The 'package' is expected to be the same data structure as returned by the encrypt_pk() function, and 'pk_key' must be the same dict structure as returned by gen_pk(). The package type is checked, and CryptoPkgType- Error is raised for the wrong type. A few checks are performed prior to decryption: 1) the key must have PK_CAP_ENCRYPT capability, 2) the key must have a private component, and 3) key fingerprint must be listed in the package (as a dict key). Otherwise 1) CryptoPKCapabilityError, 2) TypeError, or 3) ValueError (2 and 3 to mimic PKCS1_OAEP module behavior) exceptions are raised. A valid private key is used to decrypt the secret key, which is then passed to decrypt() function along with the symmetrically encrypted package. Output from decrypt() is returned as a result. Failed decryption raises ValueError. TODO: Make threaded. Symmetric encryption and asymmetric operations could probably be performed in parallel (needs benchmarking). ''' if package[0] is not PACKAGE_PK: raise exc.CryptoPkgTypeError( 'wrong package type provided for decryption') _, encrypted_keys, encrypted_package = package try: key, created = pk_key[PK_CAP_ENCRYPT] except KeyError: raise exc.CryptoPKCapabilityError('incompatible PK capabilities') if not key.has_private(): raise TypeError('private key is missing') try: fp = fingerprint(key, created) secret_key = PK_ENC.new(key).decrypt(encrypted_keys[fp]) except KeyError: raise ValueError('wrong private key provided for decryption') return decrypt(encrypted_package, secret_key)

— Гость (27/11/2013 22:00)   
На счет моего владения Python, я новичок, но Ваш код понял и без комментариев, хотя конечно не до конца и не сразу. Ну т.е. код я читать могу, а сам написать не смогу подобное. Хотя у Вас там так все документировано, что можно просто в конце файла продублировать твои функции с префиксом doc и вызывать их как справку. А где код движка посмотреть можно? За Drive into Python отдельное спасибо, ознакомлюсь. Дадите пару советов по скорейшему овладеванию программированием?

— Гость (28/11/2013 00:05)   

В 2014-ом году.


Учиться, учиться и ещё раз учиться © Ленин.

— SATtva (28/11/2013 14:15)   

На счет моего владения Python, я новичок, но Ваш код понял и без комментариев, хотя конечно не до конца и не сразу. Ну т.е. код я читать могу, а сам написать не смогу подобное.

Это самая простая часть движка, просто набор функций.

А где код движка посмотреть можно?

Он не завершён и не опубликован, надеюсь закончить к весне.

<Jimmy Wales mode>
Give me your money^[link4], программисты тоже хотят есть.
</Jimmy Wales mode>

Дадите пару советов по скорейшему овладеванию программированием?

Начните отсюда^[link5], далее перейдите сюда^[link6], потом к Dive into Python^[link7], а после начните писать что-то своё, желательно с использованием хороших внешних библиотек, и изучая их документацию, интерфейсы, паттерны и примеры научитесь ещё более лучше. Короче, слушайте дедушку Ленина.

— Гость (29/11/2013 20:41)   

Учиться, учиться и ещё раз учиться

Вбиваем этот ключ в Гуглокартинки и... учимся, учимся и еще раз учимся;)
В затянутом TBB (без кук и скриптов) это 2-3 страничка:)

— Гость (08/12/2013 04:20)   

Конкретное в питоне — здесь^[link8], но это не питоноспецифичная вещь, это концепт^[link9], на котором стоит ФП^[link10]. С его освоения начинается убийство в себе быдлокодера. В частности, лямбды активно используются для определения анонимных функций^[link11], через которые очень удобно записывать такие сильно упрощающие жизнь вещи, как замыкания^[link12] и карринг^[link13].


По ссылке выше на ФП сказано

Некоторые концепции и парадигмы специфичны для функционального программирования и в основном чужды императивному программированию (включая объектно-ориентированное программирование). Тем не менее, языки программирования обычно представляют собой гибрид нескольких парадигм программирования, поэтому «большей частью императивные» языки программирования могут использовать какие-либо из этих концепций.

Принципиально нет препятствий для написания программ в функциональном стиле на языках, которые традиционно не считаются функциональными, точно так же, как программы в объектно-ориентированном стиле можно писать на структурных языках. Некоторые императивные языки поддерживают типичные для функциональных языков конструкции, такие как функции высшего порядка и списковые включения (list comprehensions), что облегчает использование функционального стиля в этих языках. Примером может быть функциональное программирование на языке Python. Другим примером является язык Ruby, который имеет возможность создания как lambda-объектов, так и возможность организации анонимных функций высшего порядка через блок с помощью конструкции yield.

В любом случае, IMHO, оптимальней сначала попытаться понять математический смысл действий, а уже только потом реализацию этих действий в конкретных языках.


Самые простые вещи можно понять на пальцах. С более сложными^[link14] будут проблемы. Например, как реализовать фолдинг^[link15] в недоязыке^[link16], который его в лоб не умеет? Ну, или вот такую вещь^[link17]? Когда есть понимание связи между абстрактными концепциями, можно не сидеть, тупо выткая в синтаксис и пытаясь переизобрести велосипед, а сразу понимать, как реализовать нужную эквивалентность, потому что она непосредственно следует из математических теорем.