Je souhaite écrire un programme amorçable dans l'assembleur qui serait capable d'envoyer et de recevoir des paquets de réseau. Je ne souhaite pas utiliser de bibliothèques, je voudrais tout créer par moi-même (et aussi apprendre tout en le faisant). Malheureusement, je n'ai pas pu trouver d'informations sur la communication avec la carte réseau au niveau le plus bas (envoi des prises brutes). Je crois qu'il est nécessaire d'utiliser out et dans les instructions , bien que je ne puissiez pas trouver d'informations sur le port attribué à la carte réseau (ou comment le trouver, si ce n'est pas toujours le même). Quelqu'un pourrait-il me dire dans la bonne direction? ; -)
3 Réponses :
Différentes cartes réseau ont différentes interfaces matérielles (c'est pourquoi elles ont des pilotes de périphérique différents).
Vous pouvez obtenir des informations sur le matériel du fabricant de périphériques (ou vous pourriez ne pas: ils pourraient considérer cela comme des informations exclusives et écrire leurs propres pilotes de périphérique).
Vous pouvez également obtenir ces informations en consultant le code source des cartes réseau open source: Par exemple, je suppose que pour Linux; Ou peut-être que le Pilotes de paquets crynwr./a>.
Vous dites donc que tous les systèmes d'exploitation qui ne nécessitent pas de pilotes installés pour une carte réseau ont déjà tous les pilotes de toutes les cartes réseau existantes?
Il y a beaucoup de ces pilotes; par exemple. 20 pages de pilotes Intel à drivers.softpedia.com/get/network-card/intel
J'ai acheté ma copie de Windows préinstallées quand j'ai acheté cet ordinateur. Le fabricant de l'ordinateur ("OEM"), qui a installé le O / S, savait quel type de carte réseau qu'ils avaient placé dans cette machine et pouvait donc installer le bon pilote.
Sinon, si vous achetez une carte réseau sous forme d'add-on un après-vente, je pense que vous trouverez inclus dans sa boîte les pilotes de périphérique spécifiques à la carte pour divers O / SES.
Il existe des API "génériques", plus ou moins anciennes (et éventuellement obsolètes), qui peuvent être soutenues ou non par une carte donnée: E.G. NE2000 .
C'est un problème assez important à résoudre. Même se rendre au point de "prises brutes" va être un peu de travail.
Premièrement, avec un BIOS moderne, votre carte réseau ne sera normalement pas configurée par défaut, vous aurez donc besoin de traiter configuration PCI pour la configurer pour avoir des ports visibles au processeur. Cela vous donnera la capacité de base d'obtenir la CPU pour parler à la carte réseau.
Deuxièmement, vous devrez trouver une documentation sur le chipset particulier qu'il arrive à utiliser afin que vous sachiez comment lire et écrire des données réseau. Avec quelques cartes plus anciennes, c'était assez facile, mais la plupart des plus récents agissent comme des maîtres de bus avec du matériel de dispersion / collecte. Les programmer pour faire même un transfert simple peut être non trivial. Cela dépend complètement sur le matériel cependant.
Troisièmement, vous devrez développer une partie substantielle d'une pile IP pour pouvoir utiliser des prises même brutes. Au niveau matériel, vous avez essentiellement deux capacités: Recevez tous les paquets pour arriver et envoyer des paquets à des adresses MAC spécifiées - ou d'autres adresses matérielles, si votre carte n'est pas (et n'écoule pas / ACT) Ethernet.
Les prochains couches de couches au-dessus de ce serait un Résolveur ARP (pour vous laisser Utilisez des adresses IP au lieu d'adresses MAC) et d'un client DNS (vous pouvez donc utiliser des noms d'adresse normaux au lieu de quelque chose comme des quads en pointillés. Parallèlement à cela, vous voudrez probablement créer un logiciel qui sait créer / comprendre
dans X86-64 Linux, vous pouvez effectuer des appels système pour utiliser des prises brutes.
global _start
section .text:
_start:
;sys_socket: rax, 41
mov rax,41
;sys_socket inputs:
;%rdi %rsi %rdx
;family type protocol
mov rdi,2 ;AF_INET
mov rsi,2 ;DGRAM Socket
mov rdx,0 ;protocol
syscall
;sys_sendto: rax, 44
; I will do this later because rax holds the file desc
;sys_sendto inputs:
;%rdi %rsi %rdx %r10 %r8 %r9
;file desc buff lenght flags addr addr-lenght
mov rdi,rax ;file desc
mov rax,44 ;sys_sendto
mov rsi,msg ;buff
mov rdx,msgl ;length
mov r8,addr ;addr
mov r9,16 ;remember htons()??? that's why 16
syscall
section .data:
msg: db "hello"
msgl: equ $-msg
;addr
addr: dw 2
db 10h,00h ;htons()
db 7fh,0h,0h,01h
db 0,0,0,0,0,0,0,0
Cela ressemble exactement à Spam, puisque vous n'avez même pas mentionné de titre ou d'auteur pour la vidéo. Mais peu importe, même si cette vidéo est une sorte de guide ou de tutoriel, les réponses de liaison uniquement sont hors tension pour le débordement de pile. Si vous avez écrit une réponse qui décrit ce que vous devez faire et / ou inclut un code, il serait correct de lier quelque chose d'autre comme un "voir plus", mais un lien ne peut être la seule chose de votre réponse. Si vous souhaitez simplement publier un lien pertinent, comme wiki.osdev.org/network_stack , utilisez un commentaire . (Ce qui nécessite un représentant, pour des raisons de filtrage manifestement spam.)
Ce n'est pas une bonne idée d'utiliser int 0x80 en code 64 bits, en particulier pour les appels système avec le pointeur args: ce qui se passe Si vous utilisez l'ABI de 32 bits Int 0x80 Linux dans le code 64 bits?
@Petercordes désolé mais la question mentionne x86
Ouais, et ce code est destiné au mode Long 64 bits de X86: vous pouvez indiquer à partir des noms R enregistrer et utiliser r8 et r9 . On dirait que vous avez utilisé le code de la vidéo et le cassé en remplaçant syscall avec int 0x80 sans passer dans les numéros d'appel 32 bits ou le portage sur les ABI 32 bits Différente convention d'appel (EBX, ECX, EDX, ... dans cet ordre, au lieu de RDI, RSI, RDX, ... dans cet ordre). En bref, vous devriez simplement le changer vers SysCall , pour une utilisation sur des systèmes X86 de 64 bits. Vous devriez essayer d'assembler + en cours d'exécution avec strace ./a.out pour voir quel système appelle cela cela fait.
Mis à jour le code :-)
Si vous écrivez votre propre système d'exploitation, voir wiki.osdev.org/network_stack . Sinon, apportez des appels système sur un système d'exploitation existant, comme des prises brutes sur Linux.