C++ Débordement De La Mémoire Tampon

Je suis en train de me former sur les dépassements de mémoire tampon et d'exploitation en C++. Je suis un intermédiaire en C++ mec, au mieux, si patient avec moi. J'ai suivi quelques tutos, mais voici un exemple de code pour illustrer ma question:

#include <string>
#include <iostream>

using namespace std; 

int main()
{
  begin:
  int authentication = 0;
  char cUsername[10], cPassword[10];
  char cUser[10], cPass[10];

  cout << "Username: ";
  cin >> cUser;

  cout << "Pass: ";
  cin >> cPass;

  strcpy(cUsername, cUser);
  strcpy(cPassword, cPass);

  if(strcmp(cUsername, "admin") == 0 && strcmp(cPassword, "adminpass") == 0)
  {
    authentication = 1;
  }
  if(authentication)
  {
    cout << "Access granted\n";
    cout << (char)authentication;
  } 
  else 
  {
    cout << "Wrong username and password\n";
  }

  system("pause");
  goto begin;
}

Je sais qu'il y a toutes sortes de mauvais juju ici avec cin << String, etc... de toute façon, quand j'entre dans un trop grand nombre de lettres (une tonne de A's par exemple) dans cUser et cPass, je viens d'obtenir une Violation d'Accès à partir de Visual Studio. Si, toutefois, j'type 20ish A's, puis un espace, puis un autre A en cUser, il saute de me demander de cPass (en supposant que parce qu'il a été rempli après le caractère espace causé l'appel précédent de cin de retour) et il suffit de m'en donne l'accès.

À ce point, et pourquoi, sont des données qui débordent dans "authentification" et pourquoi ça ne se passe lorsque je avoir de l'espace et non pas quand j'ai un million de As '... je n'ai jamais eu la "Violation d'Accès" lorsque j'utilise un espace dans l'entrée pour cUser.

system("pause"); goto begin; Nope, assez sûr que vous êtes un débutant.
Êtes-vous essayer d'obtenir le débordement et vous demandez-vous pourquoi il fait ça? Ou voulez-vous pas de débordement et demandent une solution? Aussi, vous ne devriez pas le système(). C'est une énorme porte dérobée pour un pirate.
Aussi, j'ai un programme appelé pause sur mon système qui lance des missiles nucléaires. Donc, je ne devrais pas exécuter votre programme.
pourquoi utilisez-vous le char arrarys lorsque vous avez inclus la chaîne d'en-tête ??? aussi goto et system("pause")... je ne peux pas punir votre auto plus que vous l'avez fait.
system("command") est requis par la norme et hérité par le C++, sur toutes les plateformes. Mais son comportement est complètement plate-forme spécifique. Sur certaines plates-formes, un hacker pourrait installer un fichier qui serait jugée et exécutée à la place de celui prévu.

OriginalL'auteur sraboy | 2012-01-09

buffer c++exploit overflow

J'ai modifié votre programme un peu pour le rendre plus illustratif:

#include <iostream>

int main( void )
{
 int authentication = 0;
 char cUsername[ 10 ];
 char cPassword[ 10 ];

 std::cout << "Username: ";
 std::cin >> cUsername;

 std::cout << "Pass: ";
 std::cin >> cPassword;

 if( std::strcmp( cUsername, "admin" ) == 0 && std::strcmp( cPassword, "adminpass" ) == 0 )
 {
  authentication = 1;
 }
 if( authentication )
 {
  std::cout << "Access granted\n";
  std::cout << ( char )authentication;
 }
 else
 {
  std::cout << "Wrong username and password\n";
 }

 return ( 0 );
}

J'ai compilé avec x64 compilateur de ligne de commande MS compilateur, pas d'optimisations. Alors maintenant, nous avons un exe que nous voulons "hack". On charge le programme avec WinDbg (vraiment bon débogueur) et de prendre un coup d'oeil lors du démontage (remarquez, j'ai fourni complet des informations de débogage, pour plus de clarté):

00000001`3f1f1710 4883ec68        sub     rsp,68h
00000001`3f1f1714 488b0515db0300  mov     rax,qword ptr [Prototype_Console!__security_cookie (00000001`3f22f230)]
00000001`3f1f171b 4833c4          xor     rax,rsp
00000001`3f1f171e 4889442450      mov     qword ptr [rsp+50h],rax
00000001`3f1f1723 c744243800000000 mov     dword ptr [rsp+38h],0  //This gives us address of "authentication" on stack.
00000001`3f1f172b 488d156e1c0300  lea     rdx,[Prototype_Console!std::_Iosb<int>::end+0x78 (00000001`3f2233a0)]
00000001`3f1f1732 488d0d47f00300  lea     rcx,[Prototype_Console!std::cout (00000001`3f230780)]
00000001`3f1f1739 e8fdf9ffff      call    Prototype_Console!ILT+310(??$?6U?$char_traitsDstdstdYAAEAV?$basic_ostreamDU?$char_traitsDstd (00000001`3f1f113b)
00000001`3f1f173e 488d542428      lea     rdx,[rsp+28h] //This gives us address of "cUsername" on stack.
00000001`3f1f1743 488d0df6f00300  lea     rcx,[Prototype_Console!std::cin (00000001`3f230840)]
00000001`3f1f174a e823faffff      call    Prototype_Console!ILT+365(??$?5DU?$char_traitsDstdstdYAAEAV?$basic_istreamDU?$char_traitsDstd (00000001`3f1f1172)
00000001`3f1f174f 488d153e1c0300  lea     rdx,[Prototype_Console!std::_Iosb<int>::end+0x6c (00000001`3f223394)]
00000001`3f1f1756 488d0d23f00300  lea     rcx,[Prototype_Console!std::cout (00000001`3f230780)]
00000001`3f1f175d e8d9f9ffff      call    Prototype_Console!ILT+310(??$?6U?$char_traitsDstdstdYAAEAV?$basic_ostreamDU?$char_traitsDstd (00000001`3f1f113b)
00000001`3f1f1762 488d542440      lea     rdx,[rsp+40h] //This gives us address of "cPassword" on stack.
00000001`3f1f1767 488d0dd2f00300  lea     rcx,[Prototype_Console!std::cin (00000001`3f230840)]
00000001`3f1f176e e8fff9ffff      call    Prototype_Console!ILT+365(??$?5DU?$char_traitsDstdstdYAAEAV?$basic_istreamDU?$char_traitsDstd (00000001`3f1f1172)
00000001`3f1f1773 488d15321c0300  lea     rdx,[Prototype_Console!std::_Iosb<int>::end+0x84 (00000001`3f2233ac)]
00000001`3f1f177a 488d4c2428      lea     rcx,[rsp+28h]
00000001`3f1f177f e86c420000      call    Prototype_Console!strcmp (00000001`3f1f59f0)
00000001`3f1f1784 85c0            test    eax,eax
00000001`3f1f1786 751d            jne     Prototype_Console!main+0x95 (00000001`3f1f17a5)
00000001`3f1f1788 488d15291c0300  lea     rdx,[Prototype_Console!std::_Iosb<int>::end+0x90 (00000001`3f2233b8)]
00000001`3f1f178f 488d4c2440      lea     rcx,[rsp+40h]
00000001`3f1f1794 e857420000      call    Prototype_Console!strcmp (00000001`3f1f59f0)
00000001`3f1f1799 85c0            test    eax,eax
00000001`3f1f179b 7508            jne     Prototype_Console!main+0x95 (00000001`3f1f17a5)
00000001`3f1f179d c744243801000000 mov     dword ptr [rsp+38h],1
00000001`3f1f17a5 837c243800      cmp     dword ptr [rsp+38h],0
00000001`3f1f17aa 7426            je      Prototype_Console!main+0xc2 (00000001`3f1f17d2)
00000001`3f1f17ac 488d15151c0300  lea     rdx,[Prototype_Console!std::_Iosb<int>::end+0xa0 (00000001`3f2233c8)]
00000001`3f1f17b3 488d0dc6ef0300  lea     rcx,[Prototype_Console!std::cout (00000001`3f230780)]
00000001`3f1f17ba e87cf9ffff      call    Prototype_Console!ILT+310(??$?6U?$char_traitsDstdstdYAAEAV?$basic_ostreamDU?$char_traitsDstd (00000001`3f1f113b)
00000001`3f1f17bf 0fb6542438      movzx   edx,byte ptr [rsp+38h]
00000001`3f1f17c4 488d0db5ef0300  lea     rcx,[Prototype_Console!std::cout (00000001`3f230780)]
00000001`3f1f17cb e825f9ffff      call    Prototype_Console!ILT+240(??$?6U?$char_traitsDstdstdYAAEAV?$basic_ostreamDU?$char_traitsDstd (00000001`3f1f10f5)
00000001`3f1f17d0 eb13            jmp     Prototype_Console!main+0xd5 (00000001`3f1f17e5)
00000001`3f1f17d2 488d15ff1b0300  lea     rdx,[Prototype_Console!std::_Iosb<int>::end+0xb0 (00000001`3f2233d8)]
00000001`3f1f17d9 488d0da0ef0300  lea     rcx,[Prototype_Console!std::cout (00000001`3f230780)]
00000001`3f1f17e0 e856f9ffff      call    Prototype_Console!ILT+310(??$?6U?$char_traitsDstdstdYAAEAV?$basic_ostreamDU?$char_traitsDstd (00000001`3f1f113b)
00000001`3f1f17e5 33c0            xor     eax,eax
00000001`3f1f17e7 488b4c2450      mov     rcx,qword ptr [rsp+50h]
00000001`3f1f17ec 4833cc          xor     rcx,rsp
00000001`3f1f17ef e8bc420000      call    Prototype_Console!__security_check_cookie (00000001`3f1f5ab0)
00000001`3f1f17f4 4883c468        add     rsp,68h
00000001`3f1f17f8 c3              ret

Maintenant, puisque nous savons comment x64 pile fonctionne, nous pouvons commencer le "piratage". RSP est le pointeur de pile, pile de fonction est adresses ci-dessus RSP valeur (pile grandit vers les petites adresses). Ainsi, nous voyons que RSP+28h est où cUsername, RSP+38h est authentication, et RSP+40h est cPassword, où 28h, 38h et 40h sont hexadécimal décalages. Voici petite image pour illustrer:

-----> old RSP value //Stack frame of caller of `main` is above, stack frame of main is below 
16 bytes of
"cPassword"
+40h
8 bytes of "authentication"
+38h
16 bytes of
"cUsername"
+28h   
-----> RSP value = old RSP-68h

Que voyons-nous partir d'ici? Nous voyons que le compilateur de données alignées sur 8 octets limites: par exemple, nous avons demandé à allouer 10 octets pour cUsername, mais nous avons eu 16 octets - x64 bits pile est alignée sur la limite de 8 octets, naturellement. Cela signifie que pour écrire dans authentication nous avons besoin d'écrire dans cUsername PLUS que 16 octets (symboles). Notez également, que le compilateur mettre cPassword plus élevé que authentication - nous ne pouvons pas remplacer authentication à l'aide de cPassword, seulement cUsername.

Alors maintenant, nous avons un programme et entrée Username: 0123456789abcdef1. 0123456789abcdef = 16 octets, la prochaine 1 va être mis en octet de poids faible de authentication - assez bon pour nous:

Username: 0123456789abcdef1
Pass: whatever
Access granted
1

Merci beaucoup pour passer à travers toutes les difficultés à expliquer ce qui était apparemment une très simple question. J'apprécie l'ASM évasion et l'exemple. Vous êtes tout à fait l'instructeur!
Si vous êtes intéressé par la façon dont le compilateur génère du code, disposition de la mémoire, etc, alors que peu de programmes de test comme la vôtre sont la voie à suivre. Viens de lire un peu plus sur la plupart des communes des instructions en assembleur et de la pile mise en page pour votre PROCESSEUR, et d'obtenir un débogueur qui vous permettra de démonter. Ensuite, vous serez en mesure de voir comment votre code C/C++ est transformé en véritable machine des instructions. Il permet non seulement d'utiliser certains "trucs", mais vous donne également l'idée, par exemple, à propos de ce que les choses compilateur est capable d'optimiser etc.
Salut, je suis novice en c++. J'ai une question idiote à poser, comment pouvons-nous limiter l'entrée de l'utilisateur à la variable de taille que nous avons déclaré? Par exemple, cUsername accepte seulement 10 caractères, mais l'utilisateur peut entrer plus de ce que le droit? Il est possible d'éviter le débordement de cette variable?
Oui. Par exemple, vous pouvez utiliser std::setw(): std::cin >> std::setw(9) >> cUsername;.
De l'oci, je vous remercie beaucoup.

OriginalL'auteur lapk

2

Il est d'écraser votre authentication variable. Cela signifie que authentication est positif avant même que votre code vérifie le nom d'utilisateur et mot de passe. Pour le vérifier, imprimer authentification avant les contrôles.

Je vais développer un peu plus loin: Lorsque vous tapez est un très long nom d'utilisateur, nom d'utilisateur est copié, par votre strcpy, en cUsername. Cette variable cUsername est immédiatement après authentication et par conséquent, il est remplacé par le trop-long nom d'utilisateur.

Si vous tapez un très très long nom d'utilisateur, puis (encore une fois) l'authentification variable sera remplacée. Mais aussi maintenant, les éléments le plus haut dans la pile, tels que la valeur de retour, sera remplacé. Si votre programme écrase trop haut de la pile, puis elle sera très mal cassé et tout peut arriver. Vous essentiellement d'exécuter du code aléatoire à ce point.

Pourquoi le fait d'avoir un espace d'y empêcher une "Violation d'Accès" d'être identifié par opposition à l'écrasement de l'authentification?
Je ne pense pas que l'espace est pertinent. Tous les espaces sont traités de la même façon par cin. Je pense que votre question est "Quand j'ai environ 20 caractères dans le nom d'utilisateur, le programme procède à l'authentification, et quand j'ai beaucoup plus de caractères (par exemple 100), puis-je obtenir une violation d'accès. Pourquoi cette différence?"
Alrighty, alors. Merci pour la réponse... étant autodidacte, je peux écrire du code à partir d'ici au royaume-venir, mais je ne peux pas debug pour ma vie et ne savent pas beaucoup au sujet de la pile et l'allocation de mémoire. Apprécie l'info.
le compilateur tu utilises? J'ai fait des expériences et g++ et clang. Lorsque vous utilisez clang? La version de compilateur?
J'ai juste utilisé Visual Studio 2010, de sorte que MSVC++... selon le compilateur, je suis maintenant, pas sûr de ce que les mises à jour du/des service packs que j'ai à ce point. De manière générale, j'juste aller avec C# ou VB.NET/GDI pour mes applications, de sorte que cette C++ trucs avec la gestion de la mémoire, etc est assez nouveau pour moi. Je suis habitué à tous les code managé.

OriginalL'auteur Aaron McDaid
1

Si vous utilisez std::string, vous trouverez que votre programme sera beaucoup plus simple:
```
int main()
{
bool authenticated = false;
while(!authenticated)
{
string username;
string password;
cout << "Username: ";
getline(cin, username); //you may want to read input differently
cout << "Pass: ";
getline(cin, password); //same as above
//you'll need to check cin.fail() to see whether the stream
//had failed to read data, and exit the loop with "break".
if(username == "admin" && password == "adminpass")
{
authenticated = true;
}
else
{
cout << "Wrong username and password, try again\n";
}
}
if(authenticated)
{
cout << "Access granted\n";
}      
}
```
Edit:

En ce qui concerne votre dernière question, je pense que par défaut, cin >> string arrêter de lire le premier caractère d'espacement (c'est à dire de l'espace), donc si vous saisissez un espace, cin va s'arrêter avant qu'il corrompt les données, et si vous n'obtenez pas la violation d'accès. Si vous voulez être en mesure de lire des espaces, puis vous aurez besoin d'utiliser getline comme j'ai ci-dessus de sorte qu'il va lire l'intégralité de la ligne de texte, espaces inclus.

Merci. Je sais comment faire pour éviter ce problème, mais je suis à essayer de comprendre les spécificités derrière la différence dans la fourniture d'un espace de cin. Sans l'espace, je reçois une Violation d'Accès. Avec de l'espace, je reçois mon exploiter.
Ah! Merci. Je n'avais pas réalisé que. Donc, cin simplement cesse de lecture à l'espace et cela l'empêche de lecture trop en mémoire lorsque j'essaie de cin >> uPass. Je savais qu'il s'arrêtait dans les espaces, mais n'a pas mis 2 et 2, ainsi que sur un certain nombre de choses. Cours d'exécution à travers avec le débogueur, je peux voir ce qui se passe maintenant. Merci!

OriginalL'auteur dreamlax
1

Solution proposée pour détecter pointeur NULL et de dépassement de tampon dans memcpy, memset, strcpy avant de la main et imprimer l'emplacement (fichier:ligne) où le problème se produit:

http://htvdanh.blogspot.com/2016/09/proposed-solution-to-detect-null.html

OriginalL'auteur Danh Hoang
0

Lorsque vous compilez un programme, le compilateur décide de la façon d'organiser vos données dans la mémoire. Si un programme contient pas cochée accès à des tableaux, il peut être exploitable comme un utilisateur malveillant avec la connaissance de l'organisation des données en mémoire peuvent comprendre comment remplacer les variables critiques.

Cependant, le C++ n'est pas de vous donner un contrôle complet sur la façon dont les choses sont mises sur la pile. Les variables locales peuvent apparaître dans n'importe quel ordre dans la mémoire.

À comprendre débordement de la mémoire tampon exploits, vous devrez démonter votre programme et de se plonger dans le code machine. Cela vous donnera la disposition de la pile, y compris l'importance des adresses de retour.

Par le chemin, la "Violation d'Accès" est à venir à partir de votre programme, pas de Visual Studio. Vous avez probablement besoin de plus d'expérience avec "l'avant" de l'ingénierie avant d'entrer dans l'ingénierie inverse.

"en avant" ingénierie 😀 je me souviens de ça.
Je vais être sûr de travailler sur mon avant ingénierie... apprécier le trait d'esprit. J'essaie de comprendre pourquoi j'obtiens une "Violation d'Accès" dans un cas et pas dans l'autre (avec l'espace).
Pas conçu comme un trait d'esprit ou un jab... de toute façon les résultats sont imprévisibles, car vous ne démarre pas avec suffisamment d'informations pour faire une prédiction. Vous êtes à la prise de vue dans l'obscurité, attendez-vous à obtenir des résultats bien définis?
Je ne savais pas à quoi m'attendre. C'était tout nouveau pour moi. Votre réponse n'a pas vraiment l'expliquer. J'avais une question d'ordre pratique; votre réponse était abstrait. Combiné avec AzzA, ça aide, surtout en sachant que votre référence à "variables locales peuvent apparaître dans n'importe quel ordre" est mieux expliquée par lui, m'informant que le compilateur a tout simplement choisi de placer cPassword au-dessus de l'authentification. Je ne sais pas beaucoup au sujet de la pile et il suffit de programmer jusqu'à ce qu'il fonctionne. Ceci est ma première tentative de comprendre ce genre de choses d'un point de vue pratique. Je suis une .NET (et QBASIC) guy, de sorte que la gestion de la mémoire, etc est nouveau pour moi.

OriginalL'auteur Potatoswatter
0

Parce que vous avez votre jeu de caractères à 10 places (y compris le NULL caractère), quelque chose de plus long va déborder sur Authentication. Il existe de nombreuses façons de résoudre ce problème, le plus évident étant tout simplement faire le char plus gros. D'autres moyens serait de limiter le nombre de lettres d'un utilisateur entre à l'inscription (en supposant que c'était sur un serveur de site web). Vous pouvez également utiliser strlen(cUsername) à compter de la longueur du char tableau et demander de re-entrer le nom d'utilisateur avec moins de personnages.

EDIT:

Ok. Donc, ce que vous voulez faire est d'utiliser getline(cin,cUser) à la place. cin arrêt de la lecture à la première occurence d'un espace. getline() permettra de lire l'ensemble de la chaîne, avec ou sans espace.

Je comprends qu'il ya beaucoup de façons d'éviter cela; j'essaie juste de comprendre les concepts ici. Pourquoi suis-je qu'une "Violation d'Accès" quand il n'y a pas d'espace, mais il permet tout simplement de données supplémentaires pour être écrit sur l'authentification si j'ai un espace?
À l'aide de strlen(cUsername) pour vérifier si l'utilisateur a saisi un trop grand nombre de caractères ne fonctionne pas alors parce qu'il est trop tard. Vous voulez arrêter de lire quand cUsername est plein, de ne pas vérifier si il est trop plein par la suite.

OriginalL'auteur

Vous devez vous connecter pour publier un commentaire.

Edit: