Discussion :

[jeby6372]

Bonjour,

Mon but est la prise en main du cryptage avec python 3, j'ai donc parcouru le web ce week-end pour glaner des informations sur RSA / AES etc ... enfin ce qui pouvait ressembler à une possibilité d'encrypter des données texte pour les transmettre d'une manière la plus sécurisée possible .. sans parano non plus, juste faire en sorte que le truc soit bien chiant à lire quoi !

Honnêtemment je n'y connais pas grand chose en cryptographie. Après plusieurs heures de recherche et collecte de code et d'infos, mes tentatives échouaient à cause de problème de longueur de blocs invalides ou autres erreurs de conversion dues aux exemples fournis en Python 2.7. Je n'ai trouvé que très peu d'exemples en python 3 et les méthodes de cryptage employées me paraissaient bancales par rapport à ce que j'avais pu lire sur AES / RSA ou autres hiéroglyphes du genre.

J'ai enfin pu faire fonctionner le code ci-dessous qui accepte les caractères accentués style ISO 8859-1. En fait j'ai tout encapsuler en UTF-8 pour limiter les problèmes .. enfin je crois.

Je souhaiterais savoir si je suis sur la bonne piste et surtout si la sécurisation des données est raisonnable, encore une fois je ne cherche par une solution théoriquement inviolable. N'hésitez pas à me remonter commentaires ou suggestions et surtout les anneries que j'aurais pu faire !

merci d'avance.

note : pour la suite je souhaite transmettre au destinataire, le mot de passe de décryptage codé toujours en session sécuriseé (TLS). Le mot de passe sera différent pour chaque message d'où le besoin qu'il ait d'être automatiquement décrypté sur le client. Il sera transmis sous cryptage asymétrique RSA avec une clé la plus solide possible sans toutefois pénaliser les performances. L'objectif est de transmettre des messages ou des volumes de données importants dans des délais raisonnables.

@+ j'espère.

Pour exécuter le code ci-dessous l'installation de PyCrypto (python 3) est nécessaire.

Class Aes

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
 
import os, base64, hashlib
from Crypto.Cipher import AES
 
class Aes(object):
    '''
    Crypte / décrypte un texte donné en AES mode CBC. Accepte l'encodage base64.
    Encrypts input text string & decrypts bytes encoded string with or without base64 encoding
    
    Author: emmanuel.brunet@live.fr - 12/2013
    ''' 
 
    SALT_LENGTH = 64
    DERIVATION_ROUNDS=10000
    BLOCK_SIZE = 16
    KEY_SIZE = 256
    MODE = AES.MODE_CBC
 
    def encrypt(self, source, aes_key, outfile=None, base64_encode=False):
        '''
        Crypte l'entrée source en AES mode CBC avec sortie encodage base64 / fichier facultative
        
        
        @param bytes password: password in byte
        @param str plaintext: text to encode or text file path
        @parm str outfile: disk file to write encoded text to. defaults to None
        @param bool base64_encode: returns base64 encoded string if True (for emails) or bytes if False
        
        @return bytes ciphertext: the bytes encoded string.
        '''
 
 
        '''
        ----------------------------
        Traitement des entrées
        ----------------------------
        '''
        if os.path.exists(source):
 
            fp = open(source, 'rb')
            input_text = fp.read()
            fp.close()
 
        else:
 
            input_text = bytes(source, 'UTF-8')
 
        if input_text == b'':
            print('No data to encrypt')
            return
 
        padding_len = 16 - (len(input_text) % 16)         
        padded_text = str(input_text, 'UTF-8') + chr(padding_len) * padding_len
 
        '''
        ---------------------------------------------------------
        Calcul de la clé dérivée (derived_key). 
        ---------------------------------------------------------
        Elle permet d'utiliser la clé initiale (aes_key) plusieurs 
        fois, une pour chaque bloc à encrypter.
        ---------------------------------------------------------
        '''
 
        salt = os.urandom(self.SALT_LENGTH)
 
        derived_key = bytes(aes_key, 'UTF-8')     
 
        for unused in range(0,self.DERIVATION_ROUNDS):
 
            derived_key = hashlib.sha256(derived_key + salt).digest()
 
        derived_key = derived_key[:self.KEY_SIZE]
 
        '''
        ----------------
        Encryptage
        ----------------
        '''      
        # le vecteur d'initialisation doit être aléatoire
        iv = os.urandom(self.BLOCK_SIZE)
 
        cipherSpec = AES.new(derived_key, self.MODE, iv)
        cipher_text = cipherSpec.encrypt(padded_text)
        cipher_text = cipher_text + iv + salt
 
        '''
        -------------------------
        Traitement sortie
        -------------------------
        '''
        if outfile is None:
            '''
            Returns cipher in base64 encoding. Useful for email management for instance
            '''
            if base64_encode:
                return(base64.b64encode(cipher_text))
            else:
                return(cipher_text)
 
        else:
            '''
            Writes result to disk
            '''
 
            fp = open(outfile, 'w')
 
            if base64_encode:
                fp.write(base64.b64encode(cipher_text))
            else:
                fp.write(cipher_text)
 
            fp.close()
 
            print('Cipher text saved in', outfile)
 
 
    def decrypt(self, source, aes_key, outfile=None, base64_encode=False):
        '''
        @param bytes or str source: encrypted bytes string to decode or file path        
        @param bytes aes_key: password
        @parm str outfile: disk file to write encoded text to. defaults to None        
        @param bool base64_encode: cipher text is given base64 encoded (for mails content for examples)
        
        @returns str secret_text: the decoding text string or None if invalid key given
        '''
 
        '''
        ---------------------------
        Traitement des entrées
        ---------------------------
        '''
 
        if type(source) == str and os.path.exists(source):
 
            fp = open(source, 'rb')
            ciphertext = fp.read()
            fp.close()
 
        elif type(source) == bytes:
            ciphertext = source
 
        else:
            print('Invalid data source')
            return
 
        if base64_encode:
            encoded_text = base64.b64decode(ciphertext)
        else:
            # decodedCiphertext = ciphertext.decode("hex")
            encoded_text = ciphertext
 
        '''
        -------------------------
        Calcul de la clé dérivée
        -------------------------
        '''
 
        iv_start = len(encoded_text) - self.BLOCK_SIZE - self.SALT_LENGTH
        salt_start = len(encoded_text) - self.SALT_LENGTH
        data, iv, salt = encoded_text[:iv_start], encoded_text[iv_start:salt_start], encoded_text[salt_start:]
 
        derived_key = bytes(aes_key, 'utf-8')
 
        for unused in range(0, self.DERIVATION_ROUNDS):
            derived_key = hashlib.sha256(derived_key + salt).digest()
 
        derived_key = derived_key[:self.KEY_SIZE]
 
 
        '''
        -------------------------
        Décryptage
        -------------------------
        '''
        Cipher = AES.new(derived_key, self.MODE, iv)
        padded_text = Cipher.decrypt(data)
 
        padding_length = padded_text[-1]
        secret_text = padded_text[:-padding_length]
 
        '''
        Si le flux n'est pas décodé (mot de passe invalide),  la conversion UTF-8 plante ou au mieux on obtient un texte illisible
        '''
        try:
            secret_text = str(secret_text, 'utf-8')
        except:
            return
 
        if outfile is None:
 
            return(secret_text)
 
        else:
            '''
            Writes result to disk
            '''
            fp = open(outfile, 'w')
            fp.write(secret_text)
            fp.close()

Exemple

Fichier d'entrée : msg.txt
Ce texte ne peut être lu qu'après déverouillage du contenu avec la clé appropriée dy style #12?%ù$}"'~;ï.

sous python 3.2 (pas testé sous d'autres versions), placez vous dans le répertoire contenant le module developpez_crypto.py
fourni en pièce jointe. Créez le fichier msg.txt dans ce même répertoire avec un éditeur de texte

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
 
 
Python 3.2.3 (default, Sep 25 2013, 18:22:43) 
[GCC 4.6.3] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> from developpez_crypto import Aes
>>> A = Aes()
>>> A.encrypt('msg.txt', 'mdp#@%')
b'\x87Mf#\xe0gd\xa8\x83\xbelo\x83p>\x1c\xeay\xb5w#\x1d\xcc\xf7\xb69\x95\xc8\xda\xbf\xc6~\x160\xa1}\x18\xa2%=\xb9\x12\x81\xa5\xcf\xc1\xf3\xabu\x10\xf2\xf8?\xe1\x93\xcdS\x1f\xb8\xec\xd1\x96{:qH\xbfO*]\x9e\xa1\x9c\xb2>=\x8e\xba\xef\x1d\xb9\x9c\xb8\xe0\xfc\xb2\xfa\x1b\x1c\xf7\x98.Rr=sz\x86\xe4g\xe1\x06 \xfa\xe5\xbaZ\xca\xe3\xf2q0h`^\xd8U\xdc\xde\xb84 x\x10\x19N\x14\xf0\xb8\xd3\xa3\xae\x0e\x0f\x8db\xd1\xde\x01\x94\xa66\xc9\x10\xb1\'+B\x88#\xb2\xf9\x92\xf8\xd7\xedT\xae\xfe\x93w\x15;W\x8fb\x1d\xdb\xc0\x97>4;\xb0"(\xf7u\xbfY\xedU}\xe3\x9bq\xe27\xa5\x7f\xae\xdds\xa1\xc8\x95\xc8sG\xdb\n\xdb\xa2Q\xe2\xfe4\xfa'
>>> A.encrypt('msg.txt', 'mdp#@%')
b'g\xe7~\xce\x15\x16\xf1,u\x91\xb3j\x81\x8b\x8e\xc2<\x9bj5\xa3\xb4\xf8w\xc4\x83\xac\x89\xd5\xc89[\xc3@2^LlV\xef\xdf\xc5Je\xb9y\x0c\xfb\xd7\x1fs\xef\x88\xff\x7f\xe4\x8f\xb5R\x067\x10\xd6$\xee/<\xf5\x0c\xa2\xad7\xe3f\xb8\x15\x83v\x94\xd5 \xbf\x9f\xa7\x0bqL\xca\xb9\x9d\x89"\x0b\xd8\x13\x87\xbf!\x0e#\xb6\xee\x1d\xa4%*\xc2]\xdfO\x1c\x05\x99\x15\xea\xa5\xe9y!F%\x1aI*y\x9e=i\xe2\xaeb\xa5\xc7\xe4\xadsY\xdc\xeen\x8c\xa3\xfd\xef2\xa2V\xaa\xb24\x06+\xff\xe6\xdd\x8d\xdc\x07\xc9\x11,\xb4\x91\xb0\x1et\x06\xa7\xb5Lg\xeex\xb2\x83\r\x10]\x90c\x98\x04w\xa2s72\xbb\xbc)j\x931-\xdbw\xf0\x1aS\x80\xa9W\x19\x0c\xf7\x9f\xc6\xa2'

Comme vous le voyez le résultat est différent à chaque exécution. C'est l'intérêt de la clé dérivée ... génial non ?.

Maintenant on encode et on décode :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
>>> cipher = A.encrypt('msg.txt')
>>> cipher
b"\xc4\xc6p\xf9\xc0Pk8\xed\xec\x1a\x0eF\xc2n\xd0\x17m\xb1)i\x17y\xb4\x8a\xf9\xee\xc7\xb1y;\x90\x84A6\xc1n\x16\xe9\x8cf\xe8\x0cjG\x89\xc0\x9ay\x96\xb5\xf24\xb4n\xb0.\xce/\xec\x00\x83r/Bs\x95P\xe7\xfdL\xe5V}$\x93\x98\xbb\xabu\x97\x91!\xfd\xf6\x97\xc7q\x97\xd2\xcf:)<\xa1F\xacp\xf5hp\x1e\xe9\xd9\xf8\x12xp\xab\x8fh\x93\xf0c\x9e8-\x1d\x1b\xa2\xadC\xdd\x1f\xbf\xa4\xd2\x16\x9e\xbfm\xb4\xdd\x8f\xab\xd8\x80q\xd9A\xb7\x1b\xcej\x1f~3eH\x82Q\x81}\x0c\x0b\xeeo\xd3*\xc5\xcc\xa2k{\xefG\x8c\xa1\xb3\xfb?\xb61D\xe7\x9d\x99n\xe9\x1bq'i$\xfcP\xa7s[\x19\xcal\x0cD\xbb\x7f\x98I\xb8\xd2\xf6.\xec\x89\xab\xdf(\x1e"
 
>>> print(A.decrypt(cipher, 'mdp#@%'))
Ce texte ne peut être lu qu'après déverouillage du contenu avec la clé appropriée dy style #12?%ù$}"'~;ï.

En fait le plus galère ça a été la gestion de l'encodage, et je ne sais pas si c'est vraiment nikel .... donc encore une fois merci de votre retour.

[wiztricks]

Salut,

Je souhaiterais savoir si je suis sur la bonne piste et surtout si la sécurisation des données est raisonnable, encore une fois je ne cherche par une solution théoriquement inviolable.

Pourquoi ne pas utiliser une solution qui fonctionne plutôt qu'en coder une qui sera douteuse?

- W

[jeby6372]

merci de ta réponse.
Certainement, je suis en phase avec toi c'est beaucoup plus efficace et sûre. Mais c''est justement ce que je n'ai pas trouvé .

Peut être ai-je mal cherché.
Je précise aussi que je souhaite pouvoir intégrer ces fonctions dans mes programmes python existants , pas simplement envoyer un fichier texte encodé en pièce jointe via un mail, mais pouvoir encoder dynamiquement des données inter-programmes.

Et merci je vais regarder plus en profondeur ou sont les failles de sécurité

[dahtah]

merci de ta réponse.
Certainement, je suis en phase avec toi c'est beaucoup plus efficace et sûre. Mais c''est justement ce que je n'ai pas trouvé .

openssl fait ca de de base (cf enc command): http://www.openssl.org/docs/apps/enc.html

Et merci je vais regarder plus en profondeur ou sont les failles de sécurité

J'ai survole rapidement la source et j'ai rien vu d'evident (je suis loin d'etre un expert non plus). L'iv et salt sont correctement generes, et ton pbkdf2 du pauvre a l'air ok a premiere vue. J'imagine egalement que la fonction Cipher.decrypt() s'execute en temps constant fonction de la longueur du message.

Apres question performance tu peux sans doute reduire SALT_LENGTH, car la taille recommendee est 64 bits et non bytes. Pareil pour ton nombre d'iterations sur le calcul de ta cle intermediaire. Apres si tu t'en fous des perfs (ce qui a l'air d'etre le cas, vu l'application), plus c'es toujours mieux

T'as resolu la partie facile, maintenant reste a partager la cle... Tu as l'air de vouloir utiliser RSA. J'espere que la ou tu veux utiliser ca, t'as une PKI .

[wiztricks]

Je précise aussi que je souhaite pouvoir intégrer ces fonctions dans mes programmes python existants , pas simplement envoyer un fichier texte encodé en pièce jointe via un mail, mais pouvoir encoder dynamiquement des données inter-programmes

Chiffrer dynamiquement les données inter programme, encrypter des messages qui devront être "stockes" s'approchent différemment: les attaques n'ont pas le même profil.

Peut être ai-je mal cherché.

Pour ces deux cas, TLS et PGP sont un bon point de départ.
Ils sont relativement faciles a mettre en œuvre depuis Python.

On peut coder ses propres algo. mais arriver a prouver qu'ils sont robustes est un exercice a plusieurs passes: pas la peine de coder un algo. qui ne tient déjà pas la route sur le papier.
Si vous débutez en sécurité, vous n'imaginez pas le travail de fou furieux que ça représente. Et quelle sera l’utilité de construire et utiliser des codes dans lesquels vous même n'aurez pas confiance?
N'est-il pas plus profitable d’améliorer les fonctionnalités "metiers" de l'application plutôt que de le passe a coder cela?

- W

[jeby6372]

T'as resolu la partie facile, maintenant reste a partager la cle... Tu as l'air de vouloir utiliser RSA. J'espere que la ou tu veux utiliser ca, t'as une PKI .

pour ça je vais regarder du côté des DH key exchange, merci pour ton retour

[jeby6372]

Pour ces deux cas, TLS et PGP sont un bon point de départ.
Ils sont relativement faciles a mettre en œuvre depuis Python.

Je ne connaissais pas PGP. je vais regarder de cé côté, merci beaucoup pour le coup de main

[dahtah]

pour ça je vais regarder du côté des DH key exchange, merci pour ton retour

DH est compromissible par MITM. En effet si tu vois l'echange DH, rien ne t'empeche d'envoyer des premiers que tu choisis au 2 cotes de la transaction. Sauf si tu ajoutes une surcouche d'authentification, mais retour a la case PKI.
Mais ca resouds partiellement le probleme de l'echange de cles, surtout si le MITM n'est pas un probleme pour toi.

Je ne connaissais pas PGP. je vais regarder de cé côté, merci beaucoup pour le coup de main

PGP ne resouds pas le probleme de gestion des cles, c'est une forme de PKI decentralisee.

[wiztricks]

PGP ne resouds pas le probleme de gestion des cles, c'est une forme de PKI decentralisee.

Effectivement, PGP ne resoud pas la gestion des clés.
Après passer par un PKI, un serveur de clés adhoc ou expédier sa clé publique par la poste...
Tout dépend des risques que vous ne voulez pas prendre et/ou du budget que vous avez.

Le "one size fit all"... est un peu dépassé pour ceux qui pratiquent Python.
- W

[jeby6372]

Merci wiztricks et dahtah pour vos réponses. Bon là je commence à être largué ... mais je vais y revenir. Tout d'abord comme indiqué par wiztricks je pense que PGP est bien approprié à mon besoin. Je n'ai pas encore trouvé de wrapper python 3 pour ce type de bibliothèque.

Pour finaliser ce que j'ai commencé j'ai modifié le programme :

- Remplacement KDF propriétaire ou du pauvre comme spcécifié par dahtah (Lol) par PBKDF2 : package pbkdf2-1.3 devenu obligatoire.
- Remplacement de constantes "en dur"

Je joins le source (devpz_aes_0_2.py).

Sur stackoverflow on m'a fait d'autres préconisations mais je ne sais pas si elles sont valables. Vu votre niveau comparé au mien je pense que cela vous paraitra plus clair :

I) Add a HMAC to the end of your ciphertext, hash your salt and any information about the algorithm as well, check the HMAC before trusting the plaintext and padding
- Ajouter un HMAC en entée du texte encodé, hash des éléments d'algorithm et du salt, tester le HMAC avant de lancer une lecture en confiance du texte et du padding

II) Salt should be put in front of the ciphertext, otherwise you cannot decrypt efficiently (you will need all the ciphertext before being able to start decrypting)
- Placer le salt en entête du texte encodé sinon il faut lire la totalité du texte avant de pouvoir commencer à décrypter.
Ce ne serait pas un principe pour pouvoir décoder un stream en continue ? du premier abord ça me semble assez logique mais bon ... sais pas

III) You may set the IV to all zero's (and possibly not send it) if you generate a random salt each time (random IV only required if the key is re-used);
- Il est possible de charge l'IV avec des zéros (binaire, hexa .. ?) et éventuellement ne pas l'envoyer quand il est initialisé à chaque fois avec un nombre aléatoire (utiliser un IV aléatoire seulement dans le cas de réutilisation de la clé. (là je vois bien l'idée mais je ne sais pas si c'est valable)

Pour la phase II (échange de clé) si je comprends bien je dois choisir entre RSA/PKI et DH exchange ... ou autre solution ? là j'atteinds la limite de mes pauvres compétences ....

qu'en pensez vous ?

D'autre part comme indiqué par wiztricks, il m'apparaît clairement maintenant que l'encodage / décodage doit être abordés différemment que l'on se place dans un mode transfert/stockage de données (TLS/PGP) et sécurisation de transaction (TLS/ + x ?). Le + x comme système d'encryptage est pour le cas ou des données doivent être envoyés via une connection non sécurisée.

[wiztricks]

Salut,

Vous avez un forum securite sur developpez.
Ils ont des tutos/cours et les professionnels qui le fréquentent iront rarement regarder dans ce qui se passe dans un forum de programmation Python.
Pour l'instant tant que vous n'avez pas décrit ce que vous vouliez faire et quelles menaces vous espérez éviter, pas la peine de coder.
- W

[jeby6372]

J'ai appliqué de la compression/décompression bz2 sur le message à chiffrer / déchiffré.
Ca prends moins de place et ça doit être un peu plus galère à déchiffrer je pense, non ?

[jeby6372]

Ok, merci je vais changer de forum.

[dahtah]

I) Add a HMAC to the end of your ciphertext, hash your salt and any information about the algorithm as well, check the HMAC before trusting the plaintext and padding

Oui, c'est une bonne pratique d'authentifier ton bloc de texte vue qu'il transite par un chemin de non-confiance. Apres, je vois pas d'attaque directe sans HMAC, mais encore une fois je suis pas expert

II) Salt should be put in front of the ciphertext, otherwise you cannot decrypt efficiently (you will need all the ciphertext before being able to start decrypting)

Oui, effectivement, c'est plus lie a la performance ici. C'a t'evite de lire ton fichier en entier pour retrouver le salt. Mais bon, tu peux aussi faire un seek() pour postionner ton pointeur a la fin

III) You may set the IV to all zero's (and possibly not send it) if you generate a random salt each time (random IV only required if the key is re-used);

Oui, c'est vrai egalement. L'IV sert just a etre sur que XOR du premier bloc AES est toujours different pour une meme cle et un meme texte (et du coup tous les blocs suivants sont differents).
Dans le cas de la meme cle pour plusieurs textes, avoir un random IV evite d'exposer la cle dans le premier bloc.
Ici, ta cle varie en fonction du salt, donc pas de soucis.

Pour la phase II (échange de clé) si je comprends bien je dois choisir entre RSA/PKI et DH exchange ... ou autre solution ? là j'atteinds la limite de mes pauvres compétences ....

Oui, c'est a peu pres tout. Sachant que DH sans authentification est vulnerable comme dit plus haut.

D'autre part comme indiqué par wiztricks, il m'apparaît clairement maintenant que l'encodage / décodage doit être abordés différemment que l'on se place dans un mode transfert/stockage de données (TLS/PGP) et sécurisation de transaction (TLS/ + x ?). Le + x comme système d'encryptage est pour le cas ou des données doivent être envoyés via une connection non sécurisée.

Apres tu peux utiliser TLS pour le chiffrement. T'es pas oblige d'implenter x. Le seul avantage d'utiliser x est la rapidite de chiffrement compare a TLS.

J'ai appliqué de la compression/décompression bz2 sur le message à chiffrer / déchiffré.
Ca prends moins de place et ça doit être un peu plus galère à déchiffrer je pense, non ?

Tu peux encoder ton bz2 en base64 si tu veux.
Mais, ca expose surtout a d'autres classes d'attaques auxquels il faut penser soigneuseument (peut etre pas appliquable dans ton context). Des exemples de problemes entre TLS et compression: http://security.stackexchange.com/qu...or/19914#19914 (utilise padding oracle, donc pas appliquable pour toi) et TLS, HTTP et compression: http://en.wikipedia.org/wiki/BREACH_...ity_exploit%29
Mais HMAC doit

Bon courage.

[stalacta]

Bonjour, tout d'abord, désolé de remonter une discussion si ancienne et résolue mais je voulais en profiter pour demander ou vous aviez trouvé le module crypto pour Python 3. J'ai regardé sur ce site magique mais je n'ai rien trouvé, du moins rien sous le nom de crypto ou PyCrypto, ni rien non plus sur les nombreux sites web que j'ai visités avec une recherche google. Merci d'avance de votre aide.

[fred1599]

Dans la dernière version 2.6.1 stable, il semble que dans les sources, il y est des preuves de son acceptation

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
try:
    # Python 3
    from distutils.command.build_py import build_py_2to3 as build_py
except ImportError:
    # Python 2
    from distutils.command.build_py import build_py

[wiztricks]

Dans la dernière version 2.6.1 stable, il semble que dans les sources, il y est des preuves de son acceptation

Il est préférable d'aller voir dans le change log. Le support de python3 est la depuis la 2.4.

... mais je voulais en profiter pour demander ou vous aviez trouvé le module crypto pour Python 3. J'ai regardé sur ce site magique mais je n'ai rien trouvé

Ah ben oui, Christoph Gohlke n'a pas compile ce package pour vous.
Une recherche sur Google "pycrypto windows binaries" pointe ici.
Mais comme pour les packages de Gohlke, ce n'est a utiliser qu'en dépannage: les options de ces builds ne sont peut être pas celles que vous voulez.

- W

[fred1599]

Il est préférable d'aller voir dans le change log. Le support de python3 est la depuis la 2.4.

Je l'avais vu, est d'ailleurs il était stipulé dans un post stackoverflow.

J'ai voulu vérifier dans les sources du setup, si la configuration python 3.x était bien prise en compte

[stalacta]

Merci de vos réponses mais j'ai un problème :
J'ai téléchargé un .zip ici. J'ai ajouté un petit fichier batch dedans :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
"C:\python 33\python.exe" setup.py build
pause

La construction se fait, mais il y a une erreur sur la fin (je vous recopie la fin du build) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
running build_ext
warning : GMP or MPIR library not found; Not building Crypto.PublicKey._fastmath.
 
building 'Crypto.Random.OSRNG.winrandom' extension
error : Unable to find vcvarsall.bat

Si je copie le dossier obtenu dans le répertoire Python, pas de problème à première vue mais il manque certains modules. Comment faire ? merci d'avance

[wiztricks]

Salut,

L’intérêt des "pycrypto windows binaries" est de ne pas avoir a compiler soi même. Cela évite d'avoir a faire l'effort d'installer une toolchain: ensemble de programmes qui sait interpréter un fichier makefile, un compilo, un loader,...

Le message:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
building 'Crypto.Random.OSRNG.winrandom' extension
error : Unable to find vcvarsall.bat

indique que, par défaut, sous Windows, le package cherche a compiler les extensions avec Visual Studio...

- W