GTC (encore) - Page 1

Salut à tous

je débarque sur ti. J'aimerais faire du C on-calto et donc avoir gtc. Qu'en est-il de la polémique qui tournait autour ? Ou puis-je l'avoir ?

Merci

Sinon envoyez le moi
quentindupuis/arobase/hotmail.fr

lemoutonfou (./1) :
Sinon envoyez le moiquentindupuis/arobase/hotmail.fr

"et que ça saute", t'as oublié

J'ai hésité à poster "in before troll"... j'aurais dû . Enfin, Kevin n'est pas encore passé

(Sinon, pour tout savoir sur GTC, list topics/111515-gtc-derniere et tu sauras tout)

Je souhaiterais l'avoir rapidement mais certains le prenne mal

"et que ça saute"

. Enfin merci pour vos réponse mais dans le post on ne sait pas trop ou on en est ,on peut espérer que ça ait avancé depuis 2007.

Je soulignais juste le fait qu'une petite formule de politesse ne t'aurait pas couté tellement plus cher...

lemoutonfou (./4) :
[…] on peut espérer que ça ait avancé depuis 2007.

Heu… Les posts du topic mis en lien en ./3 datent de 2008. Et même du milieu de ce mois.

Cela dit, si un généreux bandit lui envoie GTC, ce sera une version de 2006. Il n'y a pas eu de nouvelle signature depuis.

mais j'y pensais moi, on peut pas la hacker cette putain de signature? il s'agit de quoi, factoriser un RSA 512, c'est faisable maintenant! (surtout avec une appli distribuée et quelques volontaires)

Il paraît même que c'est faisable en quelques heures. Des chercheurs de je-ne-sais-plus-quelle-université se sont rendus compte que les cartes graphiques étaient parfaitement adaptées pour décrypter le RSA : leur processeur est prévu pour faire du calcul parallèle massif. En les détournant de leur usage pour leur faire décoder du RSA, ils ont obtenu des temps de traitement comparables à ceux obtenus avec des supercalculateurs... avec un simple ordinateur de bureau

le blabla c'est bien encore faut il le faire.

http://www.rsa.com/rsalabs/node.asp?id=2964

pour RSA 640 bits:
The effort took approximately 30 2.2GHz-Opteron-CPU years according to the submitters, over five months of calendar time.

c'est pas des algos de pédés qui testent la divisibilité.

Et il y a 2 clés différentes, une pour les TI-89/89 Titanium et une pour les TI-92+/Voyage 200.

c'est pas très grave ça, on fera les deux

franchement, je sais que c'est pas très légal mais bon, vu que les machines sont presque en fin de vie... ça vous brancherait?

squalyl (./12) :
c'est pas très grave ça, on fera les deux

Le blabla c'est bien, encore faut-il le faire

Si tu écris un programme qui va bien, j'ai une geforce 8 qui ne sert pas souvent à grand chose...Mais pas question pour ma part d'écrire une seule ligne de code à ce propos

c'est clair

(en fait je lance l'idée au cas ou des gens soient intéressés, quoi, pour savoir, et après on essayera de voir comment faire (mais si tlm s'en fiche je me friserai pas la moustache quoi))

han coder un truc BOINC qui utilise CUDA pour casser des clés RSA

je vais me faire embaucher par la NSA après

moi j'ai une ps3 sous-utilisée qui serait ravie de mouliner pour ça, mais comme Ximoon à propos du code

déja faudrait savoir
quelles sont les clés dispo
quelles hypothèses ils faut faire
quel code est nécessaire

(j'ose pas faire un call hippo && pollux pour ça )

ah y'a déja des gens qui font des trucs sympas avec des GPUs^^

http://bvernoux.free.fr/md5/index.php

C'est clair que ce serait génial si on réussissait à faire ça !
Par contre, personnellement, je ne sais pas trop ce que je peux faire. Si tu as des idées Squalyl...

ben y'aurait pas besoin de faire grand chose, juste lancer un soft et attendre

par contre pour celui qui coderait y'aurait:

-développement d'un outil "local"
-mise en place d'une architecture réseau (éventuellement avec BOINC qui fait marcher Seti@home, mais on peut envisager un truc personnalisé)


Une clé RSA est basée sur le produit de deux nombres premiers énormes. Deux nombres de 256 bits pour le cas de la TI, soit deux fois la longueur d'un MD5 pour chaque nombre.

en gros: on se base sur 3 nombres: un impair E (en général, 0x10001, soit 65537) et deux grands nombres premiers P et Q.

On garde P et Q secrets.

on calcule N=PQ

En gros, dans la clé publique, on donne le produit des deux nombres N et l'exposant E.

L'idée c'est qu'il est super dur de retrouver P et Q à partir de N.

si N=15 alors P=3 et Q=5

mais si N est énorme, c'est super difficile (long en tout cas)
Le principe que j'imagine c'est de choisir des grands nombres premiers, et de tester si ils divisent N. Y'a deux soucis:

Choisir des diviseurs
il faut qu'ils soient premiers. Y'a des algos compliqués pour tester si un nombre est premier ou pas, qui sont plus efficaces que tester tous les diviseurs

Tester la divisibilité.
pas de secret, pour le moment je vois pas autrement que faire la division

Le truc c'est qu'on peut partager ces calculs entre un grand nombre d'ordis, si chaque ordi s'occupe d'une partie des nombres...

une database contiendrait tous les nombres. Une "équipe de CPUs" s'occuperait de savoir s'ils sont premiers ou pas, et le serveur les virerait de la DB s'ils sont pas premiers.

Une autre "équipe de CPUs" s'occuperait de diviser la clé par les nombres premiers trouvés jusqu'à ce qu'on trouve une division qui tombe juste

vala, le principe est posé

annexe:

pour encoder il faut la clé publique (E,N)
on arrange le message en nombre M
on calcule C=M^E mod N
C est le message crypté

pour décoder il faut la clé privée (D,N) avec D qui doit être premier avec (P-1)(Q-1) (je crois)
on calcule M=C^D mod N
M est le message décrypté

pour signer un fichier il faut la clé privée
on prend M=SHA1(fichier)
on calcule S=M^D mod N
on envoie S à coté du fichier.

pour vérifier une signature:
on calcule M'=SHA1(fichier)
on calcule M=S^E mod N
on vérifie que M=M'

donc
-tout le monde peut vérifier et crypter (la clé publique est ... publique)
-seul celui qui a la clé privée peut signer et décrypter.

le seul moyen de retrouver la clé privée à partir de la clé publique est de retrouver P et Q à partir de N

ça doit déjà exister des bdd de nombres premiers non ?

Sinon vu que TI s'en fout maintenant on pourrait leur demander la clé peut être ?
ou alors
!call wormhole
--- Call : wormhole n'existe pas !

(ou pedrom)

./18: n'oublie pas ExtendeD, c'est à ma connaissance celui qui connaît le mieux les routines de cert d'AMS

On peut demander à TI leurs clés, mais je ne pense pas que ce soit très probable qu'on ait une réponse positive
Factoriser les clés est un axe, mais connaissant la légendaire robustesse d'AMS: ça pourrait peut-être valoir le coup de voir si on ne peut pas shunter la vérif de la signature, non ?
Vu que FreeFlash existe, on n'est même pas obligés de faire un hack on-calc: on peut faire un patcher on-PC/Mac qui prend un *.xxu en entrée. Ca évite de redistribuer nous-mêmes des .xxu modifiés.


Aussi, est-ce que des FlashApps mal signées survivent à un reset ? Si ce n'est pas le cas, même une méthode identique à celle de FreeFlash (si ça marche aussi pour les FlashApps) ne servirait pas à grand chose...
On peut vérifier ça au moins sur calculette réelle avec une application qui désactive la Protection et efface au moins un bit de la signature. Le patcher on-PC, qui prend en entrée des .xxu + .xxk et génère un .xxu, qui concatène tout ça, pourrait également être utile. Faudrait que je retrouve les modifs que j'y avais apportées, d'ailleurs...

./21: Heu... Au secours si tu fais çà. Rien que ta DB des nombres à tester fait 2^256.
C'est largement plus compliqué niveau math...

Pour ma part, je suis intéressé à ce genre de projet... et je suis aussi d'accord qu'on devrait plutôt regarder du côté d'AMS et de la façon dont il valide la signature... Étant donné que TI ne s'intéresse plus aux ti68k, on devrait s'arranger pour ne plus dépendre d'eux...

Ahhhhhh
Je vois que ça bouge

./24: oué je sais, mais vu que les deux nombres font 256 bits uniquement, on peut virer tous ceux qui ont des leading zéros de trop, ainsi que tous ceux qui sont pairs.

(et puis j'ai jeté des bases hein, je suis conscient qu'il faudrait des trucs bien plus sioux )

./26: peut-être, mais ce qu'il nous manque à tous, c'est le temps pour mener à bien le projet ^^

Les routines de cert n'ont à ma connaissance été désossées que partiellement. Mais je ne suis pas au courant de tout

L'outil qui a été utilisé pour générer les call/caller graphs de la doc de TIGCC pourrait être utile (moyennant des modifs pour corriger des bugs connus comme l'absence de prise en compte des A-Line qui faussait les callgraphs - OSVRegister/FreeTimer et peut-être aussi le fait que toutes les fonctions du CAS dépendent de l'event loop et soient déclarées avec "__need_in_use_bit;")... mais il semble avoir été perdu

tiens, à propos de GTC, une "erreur" :
quand on a le fichier outbin (d'une précédente compilation) qui est archivé et qu'on essaie de compiler un nouveau code, on a la boite "Compiling project" (ou un truc du genre) qui apparait mais sans rien dans la Status Line, et ça reste bloqué.
J'ai passé la soirée d'hier à essayer de savoir d'où venait ce problème (je croyais que GTC buggait, j'ai tout ré-envoyé plusieurs fois)
Il faudrait mettre une sorte de message pour prévenir qu'il y a déjà un fichier "outbin" archivé, et pourquoi pas proposer de l'effacer ou d'annuler la compilation

squalyl (./27) :
./24: oué je sais, mais vu que les deux nombres font 256 bits uniquement, on peut virer tous ceux qui ont des leading zéros de trop, ainsi que tous ceux qui sont pairs.

(et puis j'ai jeté des bases hein, je suis conscient qu'il faudrait des trucs bien plus sioux )

Tu sais il y a *vraiment beaucoup* de nombres premiers, si tu prends un nombre au hasard de l'ordre de 2^256 il a plus d'une chance sur 200 d'être premier... Ca veut dire que tu vas te retrouver avec 2^248 nombres premiers à tester, bon courage
Alors que la complexité de http://en.wikipedia.org/wiki/General_number_field_sieve tournerait plutôt autour de O(2^64)...

Sinon pour ce qui est de ton projet, je suis pas sûr qu'il soit très légal :/

tama (./29) :
tiens, à propos de GTC, une "erreur" :
quand on a le fichier outbin (d'une précédente compilation) qui est archivé et qu'on essaie de compiler un nouveau code, on a la boite "Compiling project" (ou un truc du genre) qui apparait mais sans rien dans la Status Line, et ça reste bloqué.
J'ai passé la soirée d'hier à essayer de savoir d'où venait ce problème (je croyais que GTC buggait, j'ai tout ré-envoyé plusieurs fois)
Il faudrait mettre une sorte de message pour prévenir qu'il y a déjà un fichier "outbin" archivé, et pourquoi pas proposer de l'effacer ou d'annuler la compilation

C'est noté... (cela dit outbin est pas vraiment fait pour être archivé, puisqu'il a vocation à être détruit dès la prochaine compilation : si tu as besoin de garder outbin ce serait plus logique de le renommer avant de l'archiver)