Devenir un hacker

Salut à tous !

Je vous présente une petite vidéo qui vous expliquera la voie à suivre pour devenir un hacker et par la suite travailler dans des entreprise de sécurité informatique

No ban plz, il n'y a rien d'illégal dans cette vidéo donc pas d'incitation aux actes illégaux et la vidéo est de moi donc il n'y a pas d'atteinte au droit d'auteur.

Si vous avez des questions vous pouvez me les dire sur YT ou ici, j'y répondrais.

les hacker d'belin .

Trop compliqué pour moi ton truc plok...

moi ça me plairait

en faite l'histoire des hackers a commencer avec steve job et l'altair 8800 ou job avais hacké la machine et réussi a faire de la musique,

il y a eue aussi le capitaine cruche qui lui avais hacké le téléphone des années 70's en utilisent un truc qui ce trouve dans les boites de céréales,

puis il y eue kevin micnik qui lui fu rechercher par le fbi,c'était dans les années 90's.

Fukushuu =>

LAKLAAS => rien de compliquer je parle juste de ce qu'il faut apprendre^^ les langages informatiques etc...

J'ai maté le début de ta vidéo, j'aime bien ta voix , ta vidéo semble bien, je vais demandé l'avis d'un ami ancien hacker, pas craker ce que tu dis être. Autrement ça ne m'a jamais passionné, je préfère de très loin imaginer concevoir de nouveaux algorithmes principalement en IA, faire de la recherche. J'ai travaillé avec plusieurs langage, basic, pascal, forth, lisp, mon préféré est le pascal objet parce que je peux me permettre avec des folies qu'il est très structuré, et qui bouffe moins de place en étant plus rapide que les c, c+, c++

En tout cas félicitations.

Ok merci du compliment, c'est vrai que le pascal c'est un peu du C mais plus structuré par contre y'a moins mais bon comme tout langage de prog, les possibilités sont immenses

Y a bien différent, tu as une variable en Pascal assez spécial, qui permet n'importe quoi et en fin de cette variable tu as un élément que tu peux rendre libre et inclure n'importe quoi comme un object ou un tableau. Si cette variable se trouve dans un object ça te laisse une infinité de possibilité d’interconnexion des objet entre eux.

Si tu connais le langage je peux t'offrir du code te le montrant

Je t'ai fait une offre de gascon, j'ai été cherché dans mes vestige de code, j'ai pas trouvé ce queje me proposai à te donner

La variable c'est de type record avec variant libre. C'est dans la partie libre que l'on peut même mettre un objet, et si cette objet comprend plusieurs variable record avec variant libre je pense que tu as compris les possibilité offerte. Chose qu'en C ou C++ c'est très difficile à faire est sujet à toute sorte de bug. Par son coté hyper structuré Pascal ou Modula le permettent.

Ce qui m'a gavé dans le C, c'est que je passe des heures à chercher un bug d'étourderie qui m'est signalé immédiatement lors de la compilation avec Pascal

Je connais pas le Pascal, mais ca me donne envie de me renseigner un peu plus ce que tu me dit :)

Si tu es sous un système Linux ou assimilé, tu as un super bon compilateur Lazarus, mais là pour les infos mieux vaut parler couramment la langue anglaise

Une idée de mon codage en pascal, pour te montrer que c'est fastoche.

(*

┌────────────────────────────────────────────────────────────────────────────┐

│ │

│ Définition des types │

│ │

└────────────────────────────────────────────────────────────────────────────┘

*)

TYPE

EtatWind = RECORD { Structure de stockage de l'état de la fenêtre }

WindMin, WindMax: WORD;

WhereX, WhereY : BYTE;

TextAttr : BYTE;

END;

T_Ligne = 1..25;

T_Colonne = 1..80;

T_ChaineMot = String[ 30];

T_StrTitre = STRING[78] ; { Chaîne pour la barre de titre de la fenêtre }

(*

╔═════════════════════════════════════════════════════════════════════════════╗

║▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓║

║▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓┌──────────────────────────────┐▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓║

║▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓│ Définition des procédures │▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓║

║▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓│ ──── & des fonctions ──── │▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓║

║▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓└──────────────────────────────┘▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓║

║▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓║

╚═════════════════════════════════════════════════════════════════════════════╝

*)

Procedure Move ( Var Source,But ; Taille : Word );

Procedure FillChar( Var Source;Taille : Word; Valeur : Byte );

{ Routines d'écriture directe }

Procedure WriteStr( X, Y: BYTE; S: STRING; Attr: BYTE);

Procedure WriteChar(X, Y, Count: BYTE; Ch: CHAR; Attr: BYTE);

{ Routines de gestion de fenêtre }

Procedure FillWin(Ch: CHAR; Attr: BYTE);

Procedure ReadWin(Var Buf);

Procedure WriteWin(Var Buf);

Function WinSize: WORD;

Procedure SauveWin(Var W: EtatWind);

Procedure RestoreWin(Var W: EtatWind);

Procedure GrandiWin;

Function Entoure_Text (Var Txt:String):String;

Function Chaine(longueur:Byte;Car:Char):String;

Function Car_Autour_Texte(Var Txt:String;Car:Char):String;

Function Pour_Affichage_Texte(Var Txt :String; Longueur : T_Colonne):String;

Function Mil_Txt(Txt:String;debut,Fin:Byte):T_Colonne;

Procedure Ecrit(colonne:T_Colonne;ligne:T_Ligne;Txt:String;encre,fond:Byte);

Function Droite ( Txt:String;n:Byte):String;

Function Supprimer_Droite ( Txt:String;longueur:Byte):String;

Function Supprimer_Tout_Droite( Txt:String;Car:Char):String;

Function Gauche(Txt:String;n:Byte):String;

Function Supprimer_Gauche( Txt:String;longueur:Byte):String;

Function Supprimer_Tout_Gauche( Txt:String;Car:Char):String;

Function Supprimer_Tout(Var Txt:String;Car:Char):String;

Function Supprimer_Chaine(Txt,Chaine:String):String;

Function Minuscule_Car(Var Car:Char):Char;

Function Min_Chaine(Txt:String):String;

Function Majuscule_Mot(Var Txt:String):T_ChaineMot;

Function Majuscule_Nom(Txt:String):String;

Function Majuscule_Chaine(Txt:String):String;

Function Saisi:Char;

Function Chaine_Nombre( x : Extended; Entier,Decimale: Byte ):T_ChaineMot;

Function Centre_Chaine(Txt :String; Long : Byte; Car : Char): String;

(*

┌────────────────────────────────────────────────────────────────────────────┐

│¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸ « IMPLEMENTATION » ¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸¸│

└────────────────────────────────────────────────────────────────────────────┘

*)

Implementation

Procedure Move ( Var Source,But; Taille : Word );

Begin

ASM

Mov Dx,Ds { Sauvegarde de Ds data segment }

Mov Cx,Taille

Mov Ax,Cx

OR cx,cx { If Taille = 0 THEN }

Jz @Fin

{ On traite }

Mov Bx,Cx

SHR cx,1

AND Bx,$0001 { Taille = 2*Cx+Bx }

{ Taille = Ax }

Les DI,But { Les adresses de la source et du but }

Lds Si,Source

Cmp SI,DI { Si base départ > base arrivée }

Jnb @sensp { Copie croissante }

Std

Dec Ax

Add SI,Ax { Préparation de la copie décroissante }

Add DI,Ax { On pointe sur la fin de la zone }

OR Bl,Bl { Nb d'octets pair ? }

jz @pair

Movsb { On en copie 1 }

OR Cx,Cx

Jz @Fin { Dans ce cas c'est fini

il n'y en q'un }

@Pair: Dec SI { On fini la préparation de copie }

Dec DI { décroissante }

Rep MovSw { enfin on y va }

Jmp @Fin { Fini pour ce cas }

@Sensp: Cld { Copie dans le sens croissant }

Or Cx,Cx { Si un seul Octet }

JZ @Seul

Rep MovSw { On copie tant que Cx <> 0 }

@Seul: OR Bl,Bl { Test la parité du Nb d'octets }

Jz @Fin { si pair on a fini }

Movsb { On copie le dernier }

@Fin: Mov Ds,Dx { On restore }

End; { du Asm }

End;

Procedure FillChar( Var Source;Taille : Word; Valeur : Byte );

Begin

Asm

Mov Cx,Taille { Le nombre d'octets }

Or Cx,Cx

JZ @Fin { Cas ou Taille = 0 }

Les Di,Source { L'adresse de la variable Es:DI }

Cld { On met l'indicateur de sens }

Mov Dx,$0001

AND Dx,Cx { Parité de taille dans Dx }

@Double: SHR Cx,1 { on traite par paire }

Mov Al,Valeur { On met un la valeur en place }

Jz @Un { Cas de un Octet }

Mov Ah,Al

Rep Stosw { On repete Word par Word }

Or Dl,Dl { Taille pair ? }

JZ @Fin { Si oui on a fini }

@Un: Stosb { Si non on met le dernier Octet }

@Fin: { C'est fini }

End; { Du Asm }

End;

{$L WIN}

Procedure WriteStr(X, Y: BYTE; S: STRING; Attr: BYTE);

EXTERNAL {WIN};

Procedure WriteChar(X, Y, Count: BYTE; Ch: CHAR; Attr: BYTE);

EXTERNAL {WIN};

Procedure FillWin(Ch: CHAR; Attr: BYTE);

EXTERNAL {WIN};

Procedure WriteWin(Var Buf);

EXTERNAL {WIN};

Procedure ReadWin(Var Buf);

EXTERNAL {WIN};

Function WinSize: WORD;

EXTERNAL {WIN};

Procedure SauveWin(Var W: EtatWind);

BEGIN

W.WindMin := WindMin;

W.WindMax := WindMax;

W.WhereX := WhereX;

W.WhereY := WhereY;

W.TextAttr := TextAttr;

END;

Procedure RestoreWin(Var W: EtatWind);

BEGIN

WindMin := W.WindMin;

WindMax := W.WindMax;

GotoXY(W.WhereX, W.WhereY);

TextAttr := W.TextAttr;

END;

Procedure GrandiWin;

BEGIN

Dec(WindMin, $0101);

Inc(WindMax, $0101);

END;

(*

┌─────────────────────────────────────────────────────────────────────────────┐

│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ « ENTOURE_TEXT » ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│

└─────────────────────────────────────────────────────────────────────────────┘

*)

Function Entoure_Text (Var Txt:String):String ;

Begin

Entoure_Text := Concat(' « ',Txt,' » ');

End { Fin de : Entoure_Text };

(*

┌─────────────────────────────────────────────────────────────────────────────┐

│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ « CHAINE » ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│

└─────────────────────────────────────────────────────────────────────────────┘

*)

Function Chaine(longueur:Byte;Car:Char):String;

Var

L_Chaine:String;

Begin

FillChar(L_Chaine[1],longueur,Ord(Car));

L_Chaine[0] := Chr(longueur);

Chaine := L_Chaine;

End { Fin de : Chaine };

(*

┌─────────────────────────────────────────────────────────────────────────────┐

│░░░░░░░░░░░░░░░░░░░░░░░░░░░░ « Car_Autour_Texte » ░░░░░░░░░░░░░░░░░░░░░░░░░░░│

└─────────────────────────────────────────────────────────────────────────────┘

*)

Function Car_Autour_Texte(Var Txt:String;Car:Char):String;

Begin

Car_Autour_Texte := Car + Txt + Car;

End { Fin de : Car_Autour_Texte };

(*

┌─────────────────────────────────────────────────────────────────────────────┐

│░░░░░░░░░░░░░░░░░░░░░░░░░░ « POUR_AFFICHAGE_TEXTE » ░░░░░░░░░░░░░░░░░░░░░░░░░│

└─────────────────────────────────────────────────────────────────────────────┘

*)

Function Pour_Affichage_Texte(Var Txt :String; Longueur : T_Colonne):String;

Var

L_long_Txt: Byte Absolute Txt;

Begin

IF L_long_Txt + 4 < Longueur THEN Pour_Affichage_Texte:= Car_Autour_Texte(Txt,' ')

ELSE

IF L_long_Txt + 2 < Longueur THEN Pour_Affichage_Texte := Txt

ELSE

Begin

L_long_Txt:= Longueur - 2;

Pour_Affichage_Texte := Txt;

End;

End { Fin de : Pour_Affichage_Texte };

(*

┌─────────────────────────────────────────────────────────────────────────────┐

│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ « MIL_TEXT » ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│

└─────────────────────────────────────────────────────────────────────────────┘

*)

Function Mil_Txt(Txt:String;debut,Fin:Byte):T_Colonne;

Var

L_Long_Txt : Byte Absolute Txt;

Begin

IF L_Long_Txt > ( Fin - Debut) THEN

Begin

Mil_Txt := Debut;

Exit;

End;

Mil_Txt := ( debut + Fin - L_Long_Txt ) SHR 1;

End { Fin de : Mil_Txt };

(*

┌─────────────────────────────────────────────────────────────────────────────┐

│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ « ECRIT » ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│

└─────────────────────────────────────────────────────────────────────────────┘

*)

Procedure Ecrit(colonne:T_Colonne;ligne:T_Ligne;Txt:String;encre,fond:Byte);

Begin

TextColor(encre);TextBackground(fond);

WriteStr( colonne,ligne,Txt,TextAttr);

End { Fin de Ecrit };

(*

┌─────────────────────────────────────────────────────────────────────────────┐

│░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ « DROITE » ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░│

└─────────────────────────────────────────────────────────────────────────────┘

*)

Function Droite(Txt:String;n:Byte) :String;

Var L_Long_Txt : Byte Absolute Txt;

Begin

Droite := Copy(Txt,Succ(L_Long_Txt - n),L_Long_Txt);

End { Fin de : Droite };

Oui bon ça passe pas bien, le copier coller c'est pas vraiment ça

Est-ce que hacker est vraiment un métier ?

Je pense que hacker ce n'est pas un métier, mais plus une attitude, une intention d'utiliser la programmation pour autre chose, un autre but !

Tout bon programmeur qui sait créer des choses via la programmation, peut être un hacker s'il le souhaite, en intervenant sur le code d'une manière différente !

Hacker c'est beaucoup d'informations et de recherches pour trouver des failles, des fonctionnements inhabituels et pouvoir intervenir dessus !

Sinon, je suis très étonné de lire que Steve jobs était un hacker ?

si c'est vrai je l'ai vu dans un docu

Est-ce que en étant un hackeur, tu vas sur le Deep Web ?

J'ai entendu dire que c'est un endroit très fréquenté par les hackeurs, et qu'il est dangereux.

Est-ce que en étant un hackeur, tu vas sur le Deep Web ?

J'ai entendu dire que c'est un endroit très fréquenté par les hackeurs, et qu'il est dangereux.

Si le deep web, c'est de pouvoir acheter des armes et de la drogue, acheter des virus pour s'en servir contre des personnes, chercher des assassins pour des mendats...

C'est top le deep web, que l'on appelle, je crois, le Darknet !

Est-ce que hacker est vraiment un métier ?

Je pense que hacker ce n'est pas un métier, mais plus une attitude, une intention d'utiliser la programmation pour autre chose, un autre but !

Tout bon programmeur qui sait créer des choses via la programmation, peut être un hacker s'il le souhaite, en intervenant sur le code d'une manière différente !

Hacker c'est beaucoup d'informations et de recherches pour trouver des failles, des fonctionnements inhabituels et pouvoir intervenir dessus !

Sinon, je suis très étonné de lire que Steve jobs était un hacker ?

Tu a raison hacker n'est pas un métier, j'ai mis ce titre parceque ma vidéo présente qq métiers au passages, dev front, back^^

Promethee_Hades => Merci pour le partage, je regarde ca des que j'ai le temps !

Hello,

J'interviens un peu tard, mais le métier qui se rapproche le plus de "hacker" est bien celui de pentester (penetration tester) :)

C'est un métier qui consiste à auditer la sécurité des entreprises et autres organisations. Ça peut être des infrastructures, des applications, ou même tout un système d'information !

Cela se fait notamment au travers de tentatives d'intrusion pour identifier les vulnérabilités, évaluer les risques (impact des vulnérabilités * probabilité de survenance des vulnérabilités), puis enfin proposer des recommandations pour remédier aux failles retrouvées.

Attention, un audit de sécurité ne se traduit pas uniquement par des tests d'intrusion (contrairement à ce qu'on a l'habitude de croire), mais aussi :

- des entretiens : et oui, les problèmes sont principalement humains ! Il faut donc savoir comment tout est organisé.

- des audits de configuration (moins amusant) : on va évaluer la configuration d'une application, infra (et j'en passe) en s'appuyant des bonnes pratiques de sécurité. Par exemple : vérifier si des algorithmes de chiffrement faibles sont utilisés, si les données confidentielles sont bien chiffrées, si des services non utilisés sont activés, etc.

- des audits de code (le moins amusant) : dans le cas des applications, on va évaluer le code source pour identifier des vulnérabilités.

- etc...

Il y a donc une partie d'analyse et une seconde partie où il va falloir formaliser ce qui a été identifié et proposer des recommandations.

Je peux encore continuer ma description, mais ça risque d'être long.

De toute manière, dès qu'on sait coder, on comprend comment ça fonctionne et on sait aussi comment rentrer dans un code, donc ce sont les intentions qui font que l'on soit Hacker ou non !

Pas forcément en fait. Le hacker veut trouver des scénarios auxquels le développeur n'y a pas pensé. Il faut donc que ce soit un bon codeur sensibilisé à la sécurité (on n'en trouve pas beaucoup).

De plus, le hacker ne va pas uniquement chercher des failles applicatives, mais aussi des vulnérabilités réseau, système, humaines, etc.

Comme expliqué plus haut, le terme hacker peut être interprété différemment, notamment en fonction de ses intentions (black hat, grey hat, white hat).