Mettre des fichiers tiers sur HP-Prime, mission impossible?

[Persalteas]

Pas (en tout cas moins) de problèmes sous linux, donc ?

Tu vas publier les deux versions en même temps ?

[Lionel Debroux]

Pas (en tout cas moins) de problèmes sous linux, donc ?

Je ne sais pas (mais très certainement): critor ne teste que sur Windows, et je n'ai pas de Prime.
Le code compile, en principe, sous Linux (même si je n'ai pas testé la compilation des derniers changements).

Tu vas publier les deux versions en même temps ?

Oui, même si une des versions ne sera alors pas testée - à moins de trouver un beta-testeur Linux

[Persalteas]

J'ai un linux et une Prime si tu veux.

[Lionel Debroux]

Avant de pouvoir tester vraiment, il faudrait déjà que j'arrive à comprendre le protocole...

Actuellement, je bloque sur la vérification d'intégrité embarquée dans les paquets. Pour le backup, je peux ignorer cette valeur, mais l'envoi et la réception de fichiers individuels ne fonctionneront pas si je ne mets pas la bonne valeur dans la requête (enfin, j'imagine - je n'ai pas essayé, en fait...) - donc il faudrait trouver l'algorithme de calcul, ce que je ne parviens pas à faire...
La valeur de vérification d'intégrité est 16 bits (ça se voit dans les paquets ci-dessous), comme dans les fichiers pour calculatrices TI d'ailleurs. Elle est située vers le début du paquet (à la fin dans les fichiers pour les machines TI). Elle change avec le nom du programme ou son contenu, donc les deux (nom et contenu) sont intégrés dans son calcul, ce qui est au demeurant tout à fait logique.

J'ai fait un programme de brute-force qui calcule CRC et checksum sur de petits paquets (correspondant à des listes L5, L6 et L7), bien entendu après avoir enlevé le checksum lui-même aux offsets 9 et 10. Il montre que ce n'est manifestement pas un checksum, car les valeurs atteintes ne sont pas assez élevées... mais à la fin du programme, le tableau hits ne contient que des 0, ce qui veut dire que l'intersection des patterns possibles pour les trois paquets est vide

Code: Tout sélectionner

#include <inttypes.h>
#include <stdio.h>
#include <string.h>

// Slow but short and easy to modify with a different poly. Can use a LUT-based implementation later.
static uint16_t crc16_update(uint16_t crc, uint8_t a, uint32_t pattern) {
    int i;

    crc ^= a;
    for (i = 0; i < 8; ++i) {
        if (crc & 1) {
            // IBM: 0x8005 0xA001 0xC002
            // CCITT: 0x1021 0x8408 0x8810
            crc = (crc >> 1) ^ (uint16_t)pattern;
        }
        else {
            crc = (crc >> 1);
        }
    }

    return crc;
}

// File with declared checksum: 0x57 0x9D at offset 9-10
static const uint8_t array2[] = {
0x00, 0xf7, 0x01, 0x00, 0x00, 0x00, 0x10, 0x03, 0x04, 0x00, 0x00, 0x4c, 0x00, 0x35, 0x00, 0x01,
0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x06, 0x10, 0x00, 0x00, 0x74, 0x02, 0x38, 0x30,
0x20, 0xd4, 0x67, 0x31, 0x38, 0xd3, 0x67, 0x31, 0x38, 0xd4, 0x67, 0x31, 0x40, 0x8d, 0x65, 0x31,
0x94, 0x1c, 0x27, 0x31, 0x08, 0x2d, 0x27, 0x31, 0x0c, 0x2d, 0x27, 0x31, 0x00, 0x00, 0x00, 0x00
};

// File with declared checksum: 0x8B 0x06 at offset 9-10
static const uint8_t array3[] = {
0x00, 0xf7, 0x01, 0x00, 0x00, 0x00, 0x10, 0x03, 0x04, 0x00, 0x00, 0x4c, 0x00, 0x36, 0x00, 0x01,
0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x06, 0x10, 0x00, 0x00, 0x74, 0x02, 0x38, 0x30,
0x28, 0xd4, 0x67, 0x31, 0x38, 0xd3, 0x67, 0x31, 0x38, 0xd4, 0x67, 0x31, 0x40, 0x8d, 0x65, 0x31,
0x94, 0x1c, 0x27, 0x31, 0x08, 0x2d, 0x27, 0x31, 0x0c, 0x2d, 0x27, 0x31, 0x00, 0x00, 0x00, 0x00
};

// File with declared checksum: 0x3F 0x70 at offset 9-10
static const uint8_t array4[] = {
0x00, 0xf7, 0x01, 0x00, 0x00, 0x00, 0x10, 0x03, 0x04, 0x00, 0x00, 0x4c, 0x00, 0x37, 0x00, 0x01,
0x00, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00, 0x31, 0x06, 0x10, 0x00, 0x00, 0x74, 0x02, 0x38, 0x30,
0x30, 0xd4, 0x67, 0x31, 0x38, 0xd3, 0x67, 0x31, 0x38, 0xd4, 0x67, 0x31, 0x40, 0x8d, 0x65, 0x31,
0x94, 0x1c, 0x27, 0x31, 0x08, 0x2d, 0x27, 0x31, 0x0c, 0x2d, 0x27, 0x31, 0x00, 0x00, 0x00, 0x00
};

#define CHUNK 64

static uint8_t hits[65536];

static void brute_force(const uint8_t * array, uint32_t size, uint32_t min_start_offset, uint32_t max_start_offset, uint32_t min_end_offset, uint32_t max_end_offset, uint16_t target1, uint16_t target2) {
    #pragma omp parallel for schedule(static, CHUNK)
    for (uint32_t xor_pattern = 0; xor_pattern <= 0xFFFF; xor_pattern++) {
        int found = 0;
        if (!(xor_pattern & (0x3FF))) {
            printf("%" PRIX32 "\n", xor_pattern);
        }
        for (int skip = 0; skip < 2; skip++) {
            for (uint32_t start_offset = min_start_offset; start_offset <= max_start_offset; start_offset++) {
                for (uint32_t end_offset = min_end_offset; end_offset <= max_end_offset; end_offset++) {
                    uint16_t computed_crc = 0xFFFF;
                    uint16_t computed_checksum = 0;
                    const uint8_t * ptr;
                    uint32_t i;
                    for (i = start_offset, ptr = &array[start_offset]; i < size - end_offset; i++, ptr++) {
                        uint8_t data = *ptr;
                        // Skip leading 0 in packets, which is not supposed to be part of the content.
                        if (skip && !(i & 63)) {
                            data = *ptr++;
                        }
                        computed_crc = crc16_update(computed_crc, data, xor_pattern);
                        computed_checksum += data;
                    }
                    if (computed_crc == target1 || computed_crc == target2 || computed_checksum == target1 || computed_checksum == target2) {
                        printf("pattern=%" PRIX16 "\tskip=%d\tstart_offset=%" PRIu32 "\tend_offset=%" PRIu32 "\tcomputed_crc=%" PRIX16 "\tcomputed_checksum=%" PRIX16"\n",
                               xor_pattern, skip, start_offset, end_offset, computed_crc, computed_checksum);
                        found = 1;
                    }
                }
            }
        }
        if (!found) {
            hits[xor_pattern] = 0;
        }
    }
}

int main(int argc, char * argv[]) {
    memset(hits, 1, sizeof(hits));
    puts("Array2");
    brute_force(array2, sizeof(array2)/sizeof(array2[0]), 0, 12, 0, 48, 0x579D, 0x9D57);
    puts("Array3");
    brute_force(array3, sizeof(array3)/sizeof(array3[0]), 0, 12, 0, 48, 0x8B06, 0x068B);
    puts("Array4");
    brute_force(array4, sizeof(array4)/sizeof(array4[0]), 0, 12, 0, 48, 0x3F70, 0x703F);
    puts("done");
    for (uint32_t i = 0; i < sizeof(hits)/sizeof(hits[0]); i++) {
        if (hits[i] != 0) {
            printf("Hit: %" PRIu32 "\n", i);
        }
    }

    return 0;
}

Quelqu'un aurait-il des idées ? Ca commence par relire mon code et voir si je n'aurais pas fait de grosse bêtise (il y en avait une hier soir) empêchant le programme de trouver, mais ça peut aller jusqu'à trouver un autre algorithme de calcul possible pour la valeur d'intégrité (mais il n'y en a pas beaucoup pour produire une valeur 16 bits !)

array1 est un tableau beaucoup plus gros, qui n'apporte rien ici, je l'ai donc enlevé.
Le programme peut être compilé avec OpenMP (GCC, Clang: -fopenmp). Sur ma machine de 2011, il s'exécute en une quinzaine de secondes, sur 8 threads. Le code nécessite C99 et utilise inttypes.h, donc il ne compile pas out of the box avec cette merde de cl.exe (le compilo de MS, qui refuse d'implémenter ce standard vieux de 14 ans): il faut au moins ajouter une paire inttypes.h+stdint.h trouvée sur Internet.

Merci d'avance

[Persalteas]

bien entendu après avoir enlevé le checksum lui-même aux offsets 9 et 10.

Désolé pour mon manque de culture, je connais le principe du checksum pour vérifier l'intégrité, mais qu'est-ce qu'un offset ?

[Lionel Debroux]

Offset = décalage, ici par rapport au début du paquet. J'ai remplacé deux octets par 0x00, 0x00 dans chacun des paquets, puisque le checksum ne peut pas faire partie de lui-même

[Persalteas]

Ah, tout simplement - Merci

[Lionel Debroux]

* sur Omnimaga, Tim Wessman a débloqué la situation en fournissant des infos qui permettent de calculer le CRC correctement. Je ne sais toujours pas pourquoi mon programme de brute-forcing ne fonctionnait pas, mais ce n'est plus très grave.
* pour les screenshots, le CRC semble différent, et je n'ai pas trouvé non plus comment le calculer. C'est moins grave que pour les fichiers, car à court terme, on peut ignorer le CRC des screenshots (alors que sans CRC correct, pas d'envoi de fichiers).
* l'envoi de fichiers marchouille depuis ce soir, encore des problèmes à régler, et davantage de tests à faire;
* la réception de fichiers individuels n'est pas testée, donc elle ne fonctionne très probablement pas, comme presque tout code non testé
* il faudra faire des expériences pour documenter et trouver davantage de commandes actuellement inconnues, à commencer par la commande bizarre 0xE7 envoyée par le HP Connectivity Kit, qui ne semble pas nécessaire pour communiquer correctement avec la machine. Si on trouve une commande de type dirlist, comme sur les TI-Z80, TI-68k et Nspire, ça sera pas mal... parce que sans une telle commande (= si le backup complet est la seule façon de savoir ce que contient la machine), la gestion des données sur la machine va être désagréable, même pour des tailles de données assez limitées, à cause du faible taux de transfert.