CSyD - divisez vos données

naingenieu · Le 01/03/2013, à 00:54

Bonjour tout le monde

Je viens vous présenter un projet tout droit tiré de mes cours de maths, j'ai nommé Can Split your Data

Le principe

Ce petit logiciel en python permet de décomposer un mot de passe, une phrase en plusieurs clés qui pourront être, toutes ou en parties, réunies pour recomposer ce "secret"
Par exemple , imaginons que vous bossiez sur un projet super important et que vous ayez l'obligation de chiffrer tout votre travail. Malheureusement il y a toujours le risque de perdre le mot de passe et le noter quelque part serait trop dangereux. Vous pouvez donc le décomposer en un nombre de clés ( disons 7 tout en sachant que seules 4 - n'importe lesquelles - pourront vous permettre de retrouver l'info ) votre mot de passe, en garder une avec vous, en mettre une sur votre serveur, en passer certaines à vos proches collaborateurs etc afin de pouvoir récupérer le mot de passe perdu en cas de besoin tout en faisant en sorte qu'il ne soit pas stocké à un seul endroit )

Le fonctionnement

Pour cela, le programme utilise les polynômes d'interpolation de Lagrange. Il va à partir de votre secret, créer un polynôme de degré (n - 1) où n est le nombre de clés nécessaires pour retrouver le secret . Chaque clé crée correspond à un point du polynôme en question.
Pour recomposer le secret, il va utiliser la formule de Lagrange afin de recomposer le polynôme initial et donc retrouver le secret. Le bonus? Si le nombre de clé fournit est inférieur au nombre de clés nécessaires au décodage, même d'un, alors le nombre de polynôme est infini et il est donc impossible de retrouver la donnée d'origine.

Ce que la version actuelle inclut

Simplement la décomposition / recomposition du secret, petit codage en base64 pour la lisibilité.

Ce que je compte ajouter pour la prochaine MAJ

Un moyen de chiffrer directement des fichiers afin d'échanger simplement un mot de passe au lieu de phrases longues etc.
J'ai déjà une version qui utilise l'AES mais en python c'est très long ( je met 6 min pour un pdf de 1,5M en AES 256 ) donc je vais voir si je met quelque chose de moins robuste mais plus rapide ....

Lien(s) de téléchargement

version 1.0 (fixed)
version 2.0

Tout commentaire sur le projet, le code, toutes suggestions, améliorations sont les bienvenues, ici ou par mail nain.genieu@gmail.com

Dernière modification par naingenieu (Le 07/03/2013, à 21:20)

pingouinux · Le 01/03/2013, à 06:05

Bonjour,
J'ai essayé de tester ton code, mais le nombre d'arguments de chiffre est erroné :

======================================================
Traceback (most recent call last):
  File "./CSyD.py", line 110, in <module>
    mainMenu(0)
  File "./CSyD.py", line 41, in mainMenu
    menuDecomp(False)
  File "./CSyD.py", line 83, in menuDecomp
    chiffre(secret, degre, nb_cle, fichier)
TypeError: chiffre() takes exactly 3 arguments (4 given)

naingenieu · Le 01/03/2013, à 07:10

En effet désolé...
J'ai mis à jour le lien, mais si tu veux corriger directement ta version, il suffit d'enlever l'argument fichier ligne 83....

Merci quand même d'avoir essayé

pingouinux · Le 01/03/2013, à 07:44

Édité : J'ai simplifié l'exemple
Bon, après correction, cela semble marcher pour une chaîne courte, mais il y a une erreur avec celle-ci :

Entrez la chaine à décomposer : abcdefghijklmnopqrstuvwxyz0123456789
Combien de clés voulez-vous qu'il soit nécessaire pour recomposer le secret > 2
Combien de clés voulez-vous générer > 3
Calcul en cours...
Les clés générés sont :
======================================================
6p-MTozLjI0NzY1NjE3MDE3MzY1NzAwOTQxMTM5MDE5M0UrNzU=
6p-MzozLjI0NzY1NjE3MDE3MzY1NzAwOTQxMTM5MDE5M0UrNzU=
6p-LTI6My4yNDc2NTYxNzAxNzM2NTcwMDk0MTEzOTAxOTNFKzc1
======================================================

Nous allons procéder à la découverte de votre secret
Rentrez les clés secrètes, finissez par FIN : 
Clé 1 > 6p-MTozLjI0NzY1NjE3MDE3MzY1NzAwOTQxMTM5MDE5M0UrNzU=
Clé 2 > 6p-MzozLjI0NzY1NjE3MDE3MzY1NzAwOTQxMTM5MDE5M0UrNzU=
Clé 3 > FIN
Découverte du secret ....
======================================================
Traceback (most recent call last):
  File "./CSyD.py", line 110, in <module>
    mainMenu(0)
  File "./CSyD.py", line 43, in mainMenu
    menuComp(False)
  File "./CSyD.py", line 106, in menuComp
    print dechiffre(keys)
  File "/media/data/data_tmp/Forum_Ubuntu/python/decomp_cle_naingenieu/dechiffre.py", line 36, in dechiffre
    x , y = int(key.split(":")[0]),int(key.split(":")[1])
ValueError: invalid literal for int() with base 10: '3.247656170173657009411390193E+75'

Dernière modification par pingouinux (Le 01/03/2013, à 07:55)

naingenieu · Le 01/03/2013, à 08:21

C'est étrange j'avais testé avec des chaines plutôt longues, apparemment pas assez...

Je vais essayer de corriger ça, merci de tes réponses en tous cas !

pingouinux · Le 01/03/2013, à 10:10

C'est un problème de précision dans Polynome.eval(). Voici une piste :

>>> from decimal import *
>>> Decimal('3247656170173657009411390193031941390081620828002577775264771438163239956833')*1
Decimal('3.247656170173657009411390193E+75')

>>> c=getcontext()
>>> c.prec
28
>>> c.prec=256

>>> Decimal('3247656170173657009411390193031941390081620828002577775264771438163239956833')*1
Decimal('3247656170173657009411390193031941390081620828002577775264771438163239956833')

naingenieu · Le 01/03/2013, à 10:18

j'ai réussi à retablir mais maintenant le problème se pose avec déchiffre j'ai pas encore eu le telps de chercher, je regarderais dans l'aprem
le soucis dabs chiffre venait pas de là mais c'est possible que ce soit le cas avec dechiffre, j'étais cinvaincu d'avoir mis la précision a 200 en fait

pingouinux · Le 01/03/2013, à 10:27

Je pense qu'il faut ajouter un truc comme ça en tête de polynome.py (avant la ligne class Polynome:) :

context=getcontext()
context.prec=256

avec éventuellement un test dans les méthodes pour s'assurer que la précision est suffisante (par exemple, dans eval, il ne doit pas y avoir d'exposant dans la valeur de retour value).

pingouinux · Le 02/03/2013, à 20:02

Hello,
J'ai regardé ton code, et l'idée est intéressante.

Remarque 1 :
Pour que les lettres accentuées soient traitées correctement, il faut travailler en base 256 (et non 128) dans les fonctions string2Int et int2String.

Remarque 2 :
Lorsque le phrase secrète est longue, le premier coefficient du polynôme est beaucoup plus grand que les autres, et il est prépondérant lorsqu'on calcule pol.eval(x). Il s'ensuit qu'une seule clé permet de retrouver une grande partie de la phrase secrète.
Par exemple, à partir de cette phrase :
Ceci est un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
j'ai généré 10 clés (base 256 dans string2Int), avec un minimum de 5 pour reconstituer la phrase.

Voici le script de décodage d'une seule clé :

$ cat test.py
#! /usr/bin/env python
# -*- coding:utf8 -*-

import sys
from base64 import  b64decode

def int2String(nombre):
    s = ""
    while nombre > 0:
        s += chr(nombre % 256)
        nombre = nombre / 256
    return s

while True :
    cle=sys.stdin.readline()
    if not cle : break
    try :
       ind,key=cle[:-1].split('-')
       x,y=b64decode(key).split(':')
       print("x=%s => %s"%(x,int2String(int(y))))
    except ValueError : pass

Voici le fichier contenant les clés générées :

$ cat cles_generees
w5Zcn-MToyMDkzNjkxMDc1MzU3Nzg3MjIyMTcxNDA2NjkwODE2NTY5OTY5ODg0OTU4MDA1Mjc2MTM5NDM5Njg5MDg2NzgwNzc2NzI5NTc1MzExNDE0MzI2MjY0NTk1MTY1NjgyMDUwNTY1NDc0NjU2NDYyMTIxMzEwMjAxNjc5NjY4MjE0ODc1MDY5MjAwNDcxNTQ1OTA1Mjg0NjM5MjYzNzMyMDgyNjMwNTg1MzgyODI1Nzc3MTcxNjYzMjg1MTg1MDc3OTExMDQxNTYwNjU3MjcxMjg2NjYxMzAzNjEyODg0MjUwNzY5ODE2MDYzOTczMjcxODcxMzg2Nzk4NjIxMzA0NjA1MjM2NTk0NDk1Njk5ODQ=
w5Zcn-MzoyMDkzNjkxMDc1MzU3Nzg3MjIyMTcxNDA2NjkwODE2NTY5OTY5ODg0OTU4MDA1Mjc2MTM5NDM5Njg5MDg2NzgwNzc2NzI5NTc1MzExNDE0MzI2MjY0NTk1MTY1NjgyMDUwNTY1NDc0NjU2NDYyMTIxMzEwMjAxNjc5NjY4MjE0ODc1MDY5MjAwNDcxNTQ1OTA1Mjg0NjM5MjYzNzMyMDgyNjMwNTg1MzgyODI1Nzc3MTcxNjYzMjg1MTg1MDc3OTExMDQxNTYwNjU3MjcxMjg2NjYxMzAzNjEyODg0MjUwNzY5ODE2MDYzOTczMjcxODcxMzg2Nzk4NjIxMzA0NjA1MjM2ODAwNDY2OTkxNzA=
w5Zcn-NToyMDkzNjkxMDc1MzU3Nzg3MjIyMTcxNDA2NjkwODE2NTY5OTY5ODg0OTU4MDA1Mjc2MTM5NDM5Njg5MDg2NzgwNzc2NzI5NTc1MzExNDE0MzI2MjY0NTk1MTY1NjgyMDUwNTY1NDc0NjU2NDYyMTIxMzEwMjAxNjc5NjY4MjE0ODc1MDY5MjAwNDcxNTQ1OTA1Mjg0NjM5MjYzNzMyMDgyNjMwNTg1MzgyODI1Nzc3MTcxNjYzMjg1MTg1MDc3OTExMDQxNTYwNjU3MjcxMjg2NjYxMzAzNjEyODg0MjUwNzY5ODE2MDYzOTczMjcxODcxMzg2Nzk4NjIxMzA0NjA1MjM4MTc1NzYxMTA3ODg=
w5Zcn-NzoyMDkzNjkxMDc1MzU3Nzg3MjIyMTcxNDA2NjkwODE2NTY5OTY5ODg0OTU4MDA1Mjc2MTM5NDM5Njg5MDg2NzgwNzc2NzI5NTc1MzExNDE0MzI2MjY0NTk1MTY1NjgyMDUwNTY1NDc0NjU2NDYyMTIxMzEwMjAxNjc5NjY4MjE0ODc1MDY5MjAwNDcxNTQ1OTA1Mjg0NjM5MjYzNzMyMDgyNjMwNTg1MzgyODI1Nzc3MTcxNjYzMjg1MTg1MDc3OTExMDQxNTYwNjU3MjcxMjg2NjYxMzAzNjEyODg0MjUwNzY5ODE2MDYzOTczMjcxODcxMzg2Nzk4NjIxMzA0NjA1MjQyNjUyMjQ1NzEzMzQ=
w5Zcn-OToyMDkzNjkxMDc1MzU3Nzg3MjIyMTcxNDA2NjkwODE2NTY5OTY5ODg0OTU4MDA1Mjc2MTM5NDM5Njg5MDg2NzgwNzc2NzI5NTc1MzExNDE0MzI2MjY0NTk1MTY1NjgyMDUwNTY1NDc0NjU2NDYyMTIxMzEwMjAxNjc5NjY4MjE0ODc1MDY5MjAwNDcxNTQ1OTA1Mjg0NjM5MjYzNzMyMDgyNjMwNTg1MzgyODI1Nzc3MTcxNjYzMjg1MTg1MDc3OTExMDQxNTYwNjU3MjcxMjg2NjYxMzAzNjEyODg0MjUwNzY5ODE2MDYzOTczMjcxODcxMzg2Nzk4NjIxMzA0NjA1MjUzMTI3MTA1OTc0NDg=
w5Zcn-MTE6MjA5MzY5MTA3NTM1Nzc4NzIyMjE3MTQwNjY5MDgxNjU2OTk2OTg4NDk1ODAwNTI3NjEzOTQzOTY4OTA4Njc4MDc3NjcyOTU3NTMxMTQxNDMyNjI2NDU5NTE2NTY4MjA1MDU2NTQ3NDY1NjQ2MjEyMTMxMDIwMTY3OTY2ODIxNDg3NTA2OTIwMDQ3MTU0NTkwNTI4NDYzOTI2MzczMjA4MjYzMDU4NTM4MjgyNTc3NzE3MTY2MzI4NTE4NTA3NzkxMTA0MTU2MDY1NzI3MTI4NjY2MTMwMzYxMjg4NDI1MDc2OTgxNjA2Mzk3MzI3MTg3MTM4Njc5ODYyMTMwNDYwNTI3MzQ2Mjg0NDU1OTE0
w5Zcn-LTI6MjA5MzY5MTA3NTM1Nzc4NzIyMjE3MTQwNjY5MDgxNjU2OTk2OTg4NDk1ODAwNTI3NjEzOTQzOTY4OTA4Njc4MDc3NjcyOTU3NTMxMTQxNDMyNjI2NDU5NTE2NTY4MjA1MDU2NTQ3NDY1NjQ2MjEyMTMxMDIwMTY3OTY2ODIxNDg3NTA2OTIwMDQ3MTU0NTkwNTI4NDYzOTI2MzczMjA4MjYzMDU4NTM4MjgyNTc3NzE3MTY2MzI4NTE4NTA3NzkxMTA0MTU2MDY1NzI3MTI4NjY2MTMwMzYxMjg4NDI1MDc2OTgxNjA2Mzk3MzI3MTg3MTM4Njc5ODYyMTMwNDYwNTIzNjYyNzY0NDU3OTI1
w5Zcn-LTQ6MjA5MzY5MTA3NTM1Nzc4NzIyMjE3MTQwNjY5MDgxNjU2OTk2OTg4NDk1ODAwNTI3NjEzOTQzOTY4OTA4Njc4MDc3NjcyOTU3NTMxMTQxNDMyNjI2NDU5NTE2NTY4MjA1MDU2NTQ3NDY1NjQ2MjEyMTMxMDIwMTY3OTY2ODIxNDg3NTA2OTIwMDQ3MTU0NTkwNTI4NDYzOTI2MzczMjA4MjYzMDU4NTM4MjgyNTc3NzE3MTY2MzI4NTE4NTA3NzkxMTA0MTU2MDY1NzI3MTI4NjY2MTMwMzYxMjg4NDI1MDc2OTgxNjA2Mzk3MzI3MTg3MTM4Njc5ODYyMTMwNDYwNTIzNzIyNzk1NTQxNzE5
w5Zcn-LTY6MjA5MzY5MTA3NTM1Nzc4NzIyMjE3MTQwNjY5MDgxNjU2OTk2OTg4NDk1ODAwNTI3NjEzOTQzOTY4OTA4Njc4MDc3NjcyOTU3NTMxMTQxNDMyNjI2NDU5NTE2NTY4MjA1MDU2NTQ3NDY1NjQ2MjEyMTMxMDIwMTY3OTY2ODIxNDg3NTA2OTIwMDQ3MTU0NTkwNTI4NDYzOTI2MzczMjA4MjYzMDU4NTM4MjgyNTc3NzE3MTY2MzI4NTE4NTA3NzkxMTA0MTU2MDY1NzI3MTI4NjY2MTMwMzYxMjg4NDI1MDc2OTgxNjA2Mzk3MzI3MTg3MTM4Njc5ODYyMTMwNDYwNTIzOTgzNzkyNzU3NTkz
w5Zcn-LTg6MjA5MzY5MTA3NTM1Nzc4NzIyMjE3MTQwNjY5MDgxNjU2OTk2OTg4NDk1ODAwNTI3NjEzOTQzOTY4OTA4Njc4MDc3NjcyOTU3NTMxMTQxNDMyNjI2NDU5NTE2NTY4MjA1MDU2NTQ3NDY1NjQ2MjEyMTMxMDIwMTY3OTY2ODIxNDg3NTA2OTIwMDQ3MTU0NTkwNTI4NDYzOTI2MzczMjA4MjYzMDU4NTM4MjgyNTc3NzE3MTY2MzI4NTE4NTA3NzkxMTA0MTU2MDY1NzI3MTI4NjY2MTMwMzYxMjg4NDI1MDc2OTgxNjA2Mzk3MzI3MTg3MTM4Njc5ODYyMTMwNDYwNTI0Njg2OTYyMjE0Njk5

Et voici le résultat, en lisant les clés une à une :

$ ./test.py <cles_generees
x=1 =>  est un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=3 => ^N%est un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=5 => ^ZSEest un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=7 => Ɖest un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=9 => H۸pfst un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=11 => g+zhst un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=-2 => ſDH!est un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=-4 => dfB/est un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=-6 => Y
          lest un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète
x=-8 => +G6fst un long texte qui me sert à tester la solidité de la méthode de décomposition de la phrase secrète

Remède proposé :
Remplacer genPoly par celui-ci :

def genPoly(nombre, degre):
    pol = [nombre]
    rnd_max=128**4
    while rnd_max<nombre : rnd_max*=2
    while degre > 0:
      # pol.append(random.randint(0,128**4 - 1))
        pol.append(random.randint(0,rnd_max - 1))
        degre -= 1
    return polynome.Polynome(pol)

pour que les coefficients du polynôme aient le même ordre de grandeur, ou que le premier soit le plus petit.

Édité :
Remarque 3 :
Avec cette chaîne de départ ABC, en générant 5 clés dont 4 obligatoires, on récupère cette chaîne lors du déchiffrement @BC. Cela est dû à une erreur d'arrondi lors de la conversion de pol.eval(0) en entier (ligne 47 de dechiffre.py, qu'il faut je pense remplacer par
return int2String(int(pol.eval(0)+polynome.Decimal(".5")))

Dernière modification par pingouinux (Le 03/03/2013, à 10:02)

pingouinux · Le 03/03/2013, à 10:11

Pour résumer les remarques ci-dessus, voici ce que j'ai changé dans tes fichiers à la suite de mes tests :

$ echo;for i in *.py;do echo "===== $i =====";diff "$i" ..;echo;done

===== chiffre.py =====
19a20,21
>     rnd_max=128**4
>     while rnd_max<nombre : rnd_max*=2
21c23
<         pol.append(random.randint(0,128**4 - 1))
---
>         pol.append(random.randint(0,rnd_max - 1))
28c30
<         s += ord(c) * (128 ** k)
---
>         s += ord(c) * (256 ** k)

===== CSyD.py =====

===== dechiffre.py =====
47c47
<     return int2String(int(pol.eval(0)))
---
>     return int2String(int(pol.eval(0)+polynome.Decimal(".5")))
52,53c52,53
<         s += chr(nombre % 128)
<         nombre = nombre / 128
---
>         s += chr(nombre % 256)
>         nombre = nombre / 256

===== polynome.py =====
12a13
> getcontext().prec=512

naingenieu · Le 04/03/2013, à 18:20

Merci beaucoup pour tes réponses et pour tout ton travail
Je suis vraiment désolé de ne pas avoir répondu plus tôt mais je suis actuellement en vacances avec très peu de moyens d'accès Internet
Je vais intégrer les changements dès que possible ( dès que j'aurais accès à mon ordinateur ).

J'ai également une question d'ordre pratique à te poser :
Comme tu le vois, chaque série de clé est générée avec en "en-tête" une chaine aléatoire qui permet à la fois de tester 'appartenance des clés à une seule série et aussi de vérifier que le nombre de clés nécessaire est le bon. Je suis en train de réfléchir à une idée qui permettrait de faire ça de manière plus "efficace" notamment en n'affichant pas de manière claire à quelle série appartient une clé. Si jamais tu as une idée elle est la bienvenue

Encore mille fois merci. As-tu un mail que tu aimerais que je cite dans le projet?

pingouinux · Le 04/03/2013, à 19:09

Salut le vacancier,

Pour ne pas s'embêter avec les problèmes de précision, il me semble préférable d'utiliser le module fractions au lieu de decimal. Le code en est de plus un peu simplifié. Voici le nouveau jeu de modifs part rapport à ta version d'origine.

===== chiffre.py =====
19a20,21
>     rnd_max=128**4
>     while rnd_max<nombre : rnd_max*=2
21c23
<         pol.append(random.randint(0,128**4 - 1))
---
>         pol.append(random.randint(0,rnd_max - 1))
28c30
<         s += ord(c) * (128 ** k)
---
>         s += ord(c) * (256 ** k)

===== CSyD.py =====
64c64
<             print "Le nombre de clés nécessaire à la recomposition du secret doit être supérieur à deux"
---
>             print "Le nombre de clés nécessaire à la recomposition du secret doit être supérieur ou égal à deux"

===== dechiffre.py =====
52,53c52,53
<         s += chr(nombre % 128)
<         nombre = nombre / 128
---
>         s += chr(nombre % 256)
>         nombre = nombre / 256

===== polynome.py =====
12c12
< from decimal import *
---
> from fractions import Fraction
18c18
<             self.coeffs.append(Decimal(str(coeff)))
---
>             self.coeffs.append(Fraction(coeff))
46d45
<             B = Decimal(str(B))
48c47
<                 C.append(Decimal(coeff) * B)
---
>                 C.append(coeff * B)

Actuellement, une clé ressemble à ceci :
```
uid-b64encode(x:y)
```
et pourrait devenir cela :
```
b64encode(uid:x:y)
```
uid étant maintenant caché, il pourrait éventuellement avoir cette forme nb_min_de_clés:chaine_aléatoire_de_longueur_fixe_ou_pas
Pour que toutes les clés ne commencent pas de la même façon, on pourrait y remplacer uid par une fonction réversible de uid et de x, par exemple.
Je ne tiens pas à divulguer mon adresse électronique, mais tu peux si tu veux me joindre par message privé.

pingouinux · Le 05/03/2013, à 10:43

Après mûre réflexion, voici une suggestion pour l'en-tête :

1) Tu génères uid comme avant

2) Tu le combines avec la chaîne représentant y (xor caractère par caractère)
Fonction combine

def combine(uid, chaine):
    l_chaine=len(chaine)
    pc=0; resul=''
    for pu in range(len(uid)) :
        resul += chr( ord(uid[pu]) ^ ord(chaine[pc]) )
        pc = (pc+1)%l_chaine
    return resul

uid1 = combine(uid,y)

3) Tu génères la clé ainsi

b64encode(uid1:x:y)

Remarque :
La fonction combine est réversible.

uid1 = combine(uid0,chaine)
uid2 = combine(uid1,chaine)

# => uid2 == uid0

Ajouté : Je viens de tester, ça marche. Voici un exemple de clés générées :

Entrez la chaine à décomposer : ma chaîne à moi
Combien de clés voulez-vous qu'il soit nécessaire pour recomposer le secret > 5
Combien de clés voulez-vous générer > 6
Calcul en cours...
Les clés générés sont :
======================================================
REJOVmE6MToxMjk1NDUzODYxNDU1NDc5ODE0NzY3ODc0MzE0NzAxMTIzMDUxOTkzNDU=
REhGUmA6MzoxODExNTQwNDM0Nzg4OTIzMjg4Mzk1ODY5MzMwMTQ2ODExMTAwOTUxMTg3
TENCVGA6NTo5MzU3NTc4MDUwOTUzOTM5NDA4ODM1NDEwNDI1ODcxOTU3MzAxNTg1ODc3
R0lOVmM6NzoyOTk1NjI1NDI0Mzk3MDMwNDEzMjYyNTEyNDQwNjQyMDM1NTI4Mzc1MDE1MQ==
R0lEUGU6LTI6MjkzMzA1NDY0MjE2MDg0Mzc0NDc3NTI5ODM3OTU0ODE3MTM0MzQ5OTc=
Q0NGUGY6LTQ6NjMxMzM4ODgxMjIyOTUwNzMzODI4MDkxMjg4MDc3MDM0MzkzMDU0OTY1
======================================================

Dernière modification par pingouinux (Le 05/03/2013, à 12:14)

naingenieu · Le 05/03/2013, à 14:59

J'avais pensé à utiliser le module fractions mais décimal me semblait mieux convenir
Très bonne idée de faire un xor sur les caractères pour l'uid

naingenieu · Le 07/03/2013, à 21:22

Nouvelle version ajoutée Un grand merci à pingouix ( j'attends ta réponse à mon mail )

J'ai mis le projet sur github si jamais des gens sont intéressés :
https://github.com/naingenieu/CSyD

Bonne soirée

Ubuntu-fr

Navigation

Liens de recherche

Annonce

#1 Le 01/03/2013, à 00:54

CSyD - divisez vos données

#2 Le 01/03/2013, à 06:05

Re : CSyD - divisez vos données

#3 Le 01/03/2013, à 07:10

Re : CSyD - divisez vos données

#4 Le 01/03/2013, à 07:44

Re : CSyD - divisez vos données

#5 Le 01/03/2013, à 08:21

Re : CSyD - divisez vos données

#6 Le 01/03/2013, à 10:10

Re : CSyD - divisez vos données

#7 Le 01/03/2013, à 10:18

Re : CSyD - divisez vos données

#8 Le 01/03/2013, à 10:27

Re : CSyD - divisez vos données

#9 Le 02/03/2013, à 20:02

Re : CSyD - divisez vos données

#10 Le 03/03/2013, à 10:11

Re : CSyD - divisez vos données

#11 Le 04/03/2013, à 18:20

Re : CSyD - divisez vos données

#12 Le 04/03/2013, à 19:09

Re : CSyD - divisez vos données

#13 Le 05/03/2013, à 10:43

Re : CSyD - divisez vos données

#14 Le 05/03/2013, à 14:59

Re : CSyD - divisez vos données

#15 Le 07/03/2013, à 21:22

Re : CSyD - divisez vos données

Pied de page des forums