Vidéothèque, fonctions principales

Version imprimable

13/03/2014, 16h07
Avatar36

Vidéothèque, fonctions principales

Bonjour,

Je viens de me lancer dans un projet de vidéothèque en C++, les logiciels que j'ai pu utiliser sur internet ne me satisfaisant pas. Je suis actuellement en train d'apprendre le C++ et je me posais plusieurs questions techniques sur la vidéothèque. Je ne demande pas de réponse précise avec exactement le code à mettre mais plutôt la démarche à adopter.

1) Je souhaiterais que ma vidéothèque se synchronise avec une base de donnée sur internet. Je sais qu'il y en a et je me pose alors la question de comment se synchroniser avec? Est-ce que c'est juste une base de donnée consultable par tous ou est-ce qu'il faut taper une URL et aller récupérer le code source de la page internet (plus complexe que l'autre solution me semble-t-il)?

2) Globalement, mes films sont présents sur un disque dur, comment faire pour que le logiciel associe des informations au film présent sur le disque? Je m'explique: la première chose que j'ai été tenté de faire est d'associer des informations par rapport au nom du fichier vidéo. Mais là c'est le drame. Si le film est renommé ou supprimé par l'utilisateur pendant que le logiciel ne tourne pas, il ne l'associera pas au prochain allumage. Du coup comment on peut faire ça? Utiliser les tags?

Merci d'avance pour vos réponses. Pour le moment ce sont mes seules questions mais il y en aura surement d'autres.

Cordialement
14/03/2014, 09h47
LittleWhite

Bonjour,

1) Vous pouvez vous connectez à une base de données et la consulter (comme le fait un site Web et autre), pas besoin de chopper un quelconque code source d'une page, ce qui serait bien difficile et instable (si la page change)
2) Une méthode pour reconnaître un fichier est d'utiliser un hash (une sorte de clé). Les méthodes classiques sont CRC32, MD5 sum (enfin, ce sont des checksums). Il y a aussi des méthodes plus avancées, notamment si l'utilisateur réencode le fichier.
14/03/2014, 11h51
Avatar36

Super merci.
Pour la base de donnée, ok. Cette partie du code devrait être assez simple à mettre en place du coup. Il faudra que je me renseigne pour voir comment ça se présente pour lier une BSD par internet.
Pour la reconnaissance, effectivement je n'avais pas pensé au hash. J'imagine qu'on doit donner le fichier (donc le film) en argument à une fonction de hashage puis il ressort une empreinte. Ce code je pourrai alors le comparer à ma base de donnée. C'est bien ça? Après je ne sais pas encore comment on donne un fichier comme argument à une fonction. Il faudra que je lise un peu plus les cours de C++.

Cordialement
02/04/2014, 08h41
Avatar36

Bonjour,
Je reviens à la charge sur la fonction de Hash. J'ai pas mal cherché sur internet mais je n'arrive pas à trouver quelque chose d'intéressant sur le sujet. Est-ce que vous pouvez m'expliquer où trouver cette fonction (quelle bibliothèque à importer) et surtout comment elle s'utilise?

Cordialement
02/04/2014, 09h19
LittleWhite

La base : http://fr.wikipedia.org/wiki/MD5
02/04/2014, 14h09
Avatar36

J'ai compris le principe de la fonction mais cela ne m'aide pas à savoir comment je vais implémenter ça dans mon code. Au passage j'ai lu ça: "L'utilisation de cette fonction de hachage dans les signatures numériques peut conduire à de multiples scénarios d'attaque1 et n'est plus considérée comme un composant fiable de l'infrastructure à clés publiques." Je ne sais pas si c'est à prendre à la légère ou pas.
Globalement je ne sais toujours pas comment je peux envoyer un film à cette fonction. De ce que j'ai lu elle marche sur des "strings" mais je n'ai rien lu sur sa capacité à recevoir n'importe quel fichier en entrée.
02/04/2014, 14h12
Avatar36

Pour signaler, j'ai quand même trouvé l'algorithme de la fonction (http://www.zedwood.com/article/cpp-md5-function), je pourrais l'implémenter dans mon code. En revanche je ne sais toujours pas comment elle va me transformer mon film (qui au passage pourra être une image ou de la musique) en variable exploitable.
04/04/2014, 10h45
Avatar36

Tout ce que j'ai lu me donne l'impression que la méthode MD5sum s'applique à des variables string. Peut-être que je n'ai pas été assez clair dans ma requête:
ce que je souhaiterais, c'est une fonction qui prend le chemin d'un fichier en argument et qui me renvoie une empreinte du dit fichier. Ce fichier peut être n'importe quel type de fichier (un film, un fichier audio, une image,...). Ceci afin de faire correspondre une entrée dans ma base de données avec le fichier réellement présent sur le disque dur. Et une fonction non basée sur le nom du fichier qui est susceptible d'être modifié par l'utilisateur!

Cordialement

Niveau sécurité aucun problème ici : tu utilises un hash (MD5 ou autre) pour reconnaître un fichier, pas dans un but de sécuriser des données (tu ne stockes pas un mot de passe par exemple).

Pour hasher un fichier : tu récupère son contenu, et c'est le contenu du fichier que tu hash. Le type et la taille du fichier importent peu (la taille du fichier impactera seulement le temps requis pour calculer un hash).

Je te conseille de ne pas réimplémenter ça, mais de trouver une implémentation fonctionnelle. Une erreur est difficilement détectable et peut totalement ruiner l'algo de hashage.
Code:

1 2 3 std::ifstream ifile("un film.mp4", std::ios::binary); auto hash = hashStream(ifile); // soit tu trouves cette fonction, soit tu la cré à partir d'une fonction de hashage fonctionnelle ifile.close();

Merci de cette réponse rapide, je sens que mon problème avance.
Qu'est-ce que tu sous-entends par implémentation fonctionnelle? Je ne me sens pas du niveau suffisant pour réaliser la fonction de hashage MD5 autrement que par un copier coller si c'est ce que tu veux dire. :aie: Est-ce que tu veux dire qu'il faut adapter le code présent sur la page que j'ai donnée? A la limite je peux essayer mais je ne suis vraiment pas certain d'y arriver.

Je viens de trouver ce code:
Code:

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 //~ Function to read the MD5 Hash of file string Tools::GetHashMd5OfFile( string FilePathToHash ) { ***** ****MD5_CTX**** ctx; ****char******* *hex_output = (char *)malloc(33); ****unsigned char** digest[MD5_DIGEST_LENGTH]; ****char******* buf[64]; ****int******** di; ***** ****//~ Open it ****ifstream inFile( FilePathToHash.c_str(), std::ios::in | std::ios::binary ); ****if ( !inFile.is_open() ) ****{ ********cout << "[E] Unable to open the in file " << FilePathToHash << " for Md5 hash." << endl; ********return ""; ****} ***** ****MD5_Init( &ctx ); ***** ****//~ Read in blocks of 64 ****while ( int count = inFile.readsome( buf, sizeof( buf ) ) ) ****{ ********MD5_Update( &ctx, buf, count ); ****} ***** ****//~ Close readed file ****inFile.close(); ***** ****//~ get the digets ****MD5_Final( digest, &ctx ); ***** ****for ( di = 0; di < 16; di++ ) ****{ ********sprintf( hex_output + di * 2, "%02x", digest[di] ); ****} ***** ****return hex_output; }
Finalement ça peut être vraiment pas mal mais il va me manquer les fonctions
-md5_init
-md5_append
-md5_finish
et les objets:
-md5_state_t
-md5_byte_t
De ce que j'ai lu, tout se trouverais dans la bibliothèque openssl/md5.h
J'ai plus qu'à essayer

Citation:

Envoyé par Avatar36

Je ne me sens pas du niveau suffisant pour réaliser la fonction de hashage MD5 autrement que par un copier coller si c'est ce que tu veux dire. :aie:

C'est plus ou moins ce que je veux dire, utiliser une lib qui gère ça correctement (openssl / Qt / l'implémentation que tu as donné quelques post plus tôt / autre...) et pas implémenter ça à la main.

Concernant le code que tu link, c'est à moitié du C avec une fuite mémoire (bref ne reprend pas ça)
Code:

1 2 3 4 5 string Tools::GetHashMd5OfFile( string FilePathToHash ) // le paramètre devrait être const& char *hex_output = (char *)malloc(33); // malloc en C++, c'est mauvais signe. // ... return hex_output ; // crée un std::string à partir d'un char*, hex_output n'est jamais libéré ! }
Le principe par contre semble être bon. Et c'est une fonction de ce style que tu vas devoir faire, fonction qui utilisera une lib tierce pour le calcul du hash. :)

04/04/2014, 13h59
Avatar36

Bon je vais essayer de faire un truc mais je m'aventure en terrain inconnu donc je risque de faire n'importe quoi ^^'
05/04/2014, 12h11
Avatar36

J'ai trouvé un code sur internet plus que prometteur:
http://softwaredevelopment.gr/86/cal...-file-using-c/
Pour le moment j'ai créé un projet de test pour essayer ce code dans Qt creator. A prioris, il à l'air tout à fait sympathique mais je ne sais pas comment rajouter les librairies qui me manquent (crypto++ et boost).
Boost: Je l'ai téléchargé, j'ai lancé bootstrap.bat pour l'installer. Et après je ne sais pas quoi faire! Je ne sais pas si c'est effectivement installé ou quoi.
Crypto++: j'ai téléchargé une archive avec plein de .h et .ccp dedans. Maintenant je ne sais pas quoi faire. Ce qui est sûr c'est que rajouter uniquement les .h et .ccp présents dans les includes du code ne suffit pas.
Un petit peu d'aide encore pour installer les librairies sur Qt creator?

Merci
05/04/2014, 12h36
Iradrille

Pour boost, soit tu as une version déjà compilé et dans ce cas tu as juste à ajouter les .h et .lib/.a au projet, soit tu as récup les sources et tu dois le build (de mémoire ya 2 trucs a faire, bootstrap + b2) voir ici (Windows), ou ici (Unix).
(build boost prend plusieurs heures en général).

Pour Crypto++, ça devrait être le même principe : tu récupère les sources, tu build la lib, et tu ajoute les .h et .lib/.a à ton projet.
05/04/2014, 21h53
Avatar36

J'ai récupéré les librairies pour crypto++. Donc ça c'est bon. par contre pour boost, je n'arrive pas à l'installer. J'ai téléchargé ça:
http://www.boost.org/users/history/version_1_55_0.html

Et j'ai suivi ces instructions:
http://www.boost.org/doc/libs/1_55_0...tallation.html

Mais d'une part l'installation par .\bootstrap.bat échoue, d'autre part je ne dispose pas de ./b2 install --prefix=PREFIX dans l'archive téléchargée. Est-ce que c'est bien la bonne archive? Est-ce que j'ai fait quelque chose de mal?

On oublie tout ce qu'on a pu faire avant. Un code qui marche avec la bibliothèque Qt se trouve ici:

Code:

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
#define HASH_READ_SIZE 8192
 
void processFile( QString strFileName )
{
    QCryptographicHash cryptoSHA(QCryptographicHash::Sha1);
    QCryptographicHash cryptoMD5(QCryptographicHash::Md5);
    QFile file(strFileName);
    if (file.open(QFile::ReadOnly)) {
        while(!file.atEnd()){
            QByteArray array = file.read(HASH_READ_SIZE);
            cryptoSHA.addData(array);
            cryptoMD5.addData(array);
        }
        QByteArray hashSHA = cryptoSHA.result();
        QByteArray hashMD5 = cryptoMD5.result();
 
        QString strHex = hashSHA.toHex();
        std::cout << qPrintable(strFileName) << ":";
        std::cout << " SHA1=" << qPrintable(strHex);
        strHex = hashMD5.toHex();
        std::cout << " MD5=" << qPrintable(strHex) << std::endl;
    }
    else
    {
        std::cerr << "ERROR: Could not open file " << qPrintable(strFileName) << std::endl;
    }
}

Cordialement