SHARE
TWEET

os4

a guest Nov 15th, 2019 101 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <windows.h>
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #define MAX_LEN 255
  6.  
  7. void getSysInfo() {
  8.     LPSYSTEM_INFO sysInfo = (LPSYSTEM_INFO)malloc(sizeof *sysInfo);
  9.     GetSystemInfo(sysInfo);
  10.     printf("Информация о системе:\n");
  11.     switch(sysInfo -> wProcessorArchitecture) {
  12.         case PROCESSOR_ARCHITECTURE_AMD64:
  13.             printf("Процессор AMD или Intel x64\n");
  14.             break;
  15.         case PROCESSOR_ARCHITECTURE_ARM:
  16.             printf("Процессор AMR\n");
  17.             break;
  18.         case PROCESSOR_ARCHITECTURE_IA64:
  19.             printf("Процессор Intel Itanium-based\n");
  20.             break;
  21.         case PROCESSOR_ARCHITECTURE_INTEL:
  22.             printf("Процессор x86\n");
  23.             break;
  24.         case PROCESSOR_ARCHITECTURE_UNKNOWN:
  25.             printf("Процессор неизвестной архитектуры\n");
  26.             break;
  27.     }
  28.     printf("Размер региона памяти: %ld\n", sysInfo -> dwPageSize);
  29.     printf("Доступны адреса памяти от %p до %p\n", sysInfo -> lpMinimumApplicationAddress, sysInfo -> lpMaximumApplicationAddress);
  30.     printf("Количество процессоров: %ld\n", sysInfo -> dwNumberOfProcessors);
  31.     printf("\"Гранулярность\" выделения памяти: %ld\n", sysInfo -> dwAllocationGranularity);    
  32. }
  33.  
  34. void getMemoryStatus() {
  35.     LPMEMORYSTATUSEX memStatus = (LPMEMORYSTATUSEX)malloc(sizeof *memStatus);
  36.     memStatus -> dwLength = sizeof *memStatus;
  37.     if (!GlobalMemoryStatusEx(memStatus))
  38.         printf("Ошибка: код ошибки %ld\n", GetLastError());
  39.     else {
  40.         printf("Используется %ld процентов памяти\n", memStatus -> dwMemoryLoad);
  41.         printf("Всего %I64d байт физической памяти\n", memStatus -> ullTotalPhys);
  42.         printf("Всего %I64d байт свободной физической памяти\n", memStatus -> ullAvailPhys);
  43.         printf("Всего %I64d байт файла подкачки \n", memStatus -> ullTotalPageFile);
  44.         printf("Всего %I64d байт свободно в файле подкачки\n", memStatus -> ullAvailPageFile);
  45.         printf("Всего %I64d байт виртуальной памяти\n", memStatus -> ullTotalVirtual);
  46.         printf("Всего %I64d байт свободной виртуальной памяти\n", memStatus -> ullAvailVirtual);
  47.     }
  48. }
  49.  
  50. void getStateByAddress() {
  51.     printf("Введите адрес участка памяти, состояние которого необходимо получить: ");
  52.     LPVOID addr;
  53.     if (scanf("%p", &addr)) {
  54.         fflush(stdin);
  55.         PMEMORY_BASIC_INFORMATION memInfo = (PMEMORY_BASIC_INFORMATION)malloc(sizeof *memInfo);
  56.         if (!VirtualQuery(addr, memInfo, sizeof *memInfo)) {
  57.             DWORD err = GetLastError();
  58.             if (err == ERROR_INVALID_PARAMETER)
  59.                 printf("Ошибка: адрес недоступен данному процессу\n");
  60.             else
  61.                 printf("Ошибка: код ошибки %ld\n", err);
  62.         }
  63.         else {
  64.             printf("Адрес (округленный): %p\n", memInfo -> BaseAddress);
  65.             printf("Адрес региона: %p\n", memInfo -> AllocationBase);
  66.             printf("Доступ к региону памяти (при его резервировании): ");
  67.             if (memInfo -> AllocationProtect & PAGE_EXECUTE)
  68.                 printf("исполнение\n");
  69.             else if (memInfo -> AllocationProtect & PAGE_EXECUTE_READ)
  70.                 printf("исполнение и чтение\n");
  71.             else if (memInfo -> AllocationProtect & PAGE_EXECUTE_READWRITE)
  72.                 printf("исполнение, чтение и запись\n");
  73.             else if (memInfo -> AllocationProtect & PAGE_EXECUTE_WRITECOPY)
  74.                 printf("исполнение, чтение и копирование при записи\n");
  75.             else if (memInfo -> AllocationProtect & PAGE_NOACCESS)
  76.                 printf("запрещен\n");
  77.             else if (memInfo -> AllocationProtect & PAGE_READONLY)
  78.                 printf("только чтение\n");
  79.             else if (memInfo -> AllocationProtect & PAGE_READWRITE)
  80.                 printf("чтение и запись\n");
  81.             else if (memInfo -> AllocationProtect & PAGE_WRITECOPY)
  82.                 printf("чтение и копирование при записи\n");
  83.             else if (memInfo -> AllocationProtect == 0)
  84.                 printf("нет доступа\n");
  85.             else
  86.                 printf("неизвестно\n");
  87.             printf("Размер региона: %I64d\n", memInfo -> RegionSize);
  88.             switch(memInfo -> State) {
  89.                 case MEM_COMMIT:
  90.                     printf("Память на страницах была выделена\n");
  91.                     break;
  92.                 case MEM_FREE:
  93.                     printf("Память на страницах свободна\n");
  94.                     break;
  95.                 case MEM_RESERVE:
  96.                     printf("Память на страницах зарезервирована\n");
  97.                     break;
  98.             }
  99.             printf("Доступ к страницам: ");
  100.             if (memInfo -> Protect & PAGE_EXECUTE)
  101.                 printf("исполнение\n");
  102.             else if (memInfo -> Protect & PAGE_EXECUTE_READ)
  103.                 printf("исполнение и чтение\n");
  104.             else if (memInfo -> Protect & PAGE_EXECUTE_READWRITE)
  105.                 printf("исполнение, чтение и запись\n");
  106.             else if (memInfo -> Protect & PAGE_EXECUTE_WRITECOPY)
  107.                 printf("исполнение, чтение и копирование при записи\n");
  108.             else if (memInfo -> Protect & PAGE_NOACCESS)
  109.                 printf("запрещен\n");
  110.             else if (memInfo -> Protect & PAGE_READONLY)
  111.                 printf("только чтение\n");
  112.             else if (memInfo -> Protect & PAGE_READWRITE)
  113.                 printf("чтение и запись\n");
  114.             else if (memInfo -> Protect & PAGE_WRITECOPY)
  115.                 printf("чтение и копирование при записи\n");
  116.             else if (memInfo -> Protect == 0)
  117.                 printf("нет доступа\n");
  118.             else
  119.                 printf("неизвестно\n");
  120.             switch(memInfo -> Type) {
  121.                 case MEM_IMAGE:
  122.                     printf("Страницы могут быть использованы дргуими процессами через модуль\n");
  123.                     break;
  124.                 case MEM_MAPPED:
  125.                     printf("Страницы могут быть использованы другими процессами\n");
  126.                     break;
  127.                 case MEM_PRIVATE:
  128.                     printf("Страницы приватны\n");
  129.                     break;
  130.             }
  131.         }
  132.     }
  133.     else {
  134.         fflush(stdin);
  135.         printf("Ошибка при считывании ввода\n");
  136.     }
  137. }
  138.  
  139. void regionReserveFree() {
  140.     int flag = 1;
  141.     do {
  142.         printf("1 - Резервирование региона\n2 - Освобождение региона\n3 - Возврат в меню\n");
  143.         char c = getchar();
  144.         fflush(stdin);
  145.         LPVOID addr;
  146.         switch (c) {
  147.             case '1':
  148.                 printf("Введите адрес участка памяти для резервирования и выделения памяти (для выделения в автоматическом режиме введите 0): ");
  149.                 scanf("%p", &addr);
  150.                 fflush(stdin);
  151.                 printf("Введите размер участка памяти для резервирования и выделения памяти: ");
  152.                 SIZE_T regSize;
  153.                 scanf("%I64d", &regSize);
  154.                 fflush(stdin);
  155.                 printf("Выполнить резервирование и выделение памяти одновременно или последовательно?\n1 - одновременно\n2 - последовательно\n");
  156.                 char c1 = getchar();
  157.                 fflush(stdin);
  158.                 LPVOID p;
  159.                 int flag1 = 1;
  160.                 do {
  161.                     switch(c1) {
  162.                         case '1':
  163.                             p = VirtualAlloc(addr, regSize, MEM_COMMIT | MEM_RESERVE, PAGE_READWRITE);
  164.                             flag1 = 0;
  165.                             break;
  166.                         case '2':
  167.                             p = VirtualAlloc(addr, regSize, MEM_RESERVE, PAGE_READWRITE);
  168.                             if (p)
  169.                                 p = VirtualAlloc(p, regSize, MEM_COMMIT, PAGE_READWRITE);
  170.                             flag1 = 0;
  171.                             break;
  172.                         default:
  173.                             printf("Ошибка ввода, попробуйте еще раз\n");
  174.                     }
  175.                 } while (flag1);
  176.                 printf("Реальный адрес, по которому выделена память: %p\n", p);
  177.                 if (!p) {
  178.                     DWORD err = GetLastError();
  179.                     if (err == ERROR_INVALID_ADDRESS)
  180.                         printf("Ошибка: неправильный адрес\n");
  181.                     else
  182.                         printf("Ошибка: код ошибки %ld\n", err);
  183.                 }
  184.                 break;
  185.             case '2':
  186.                 printf("Введите адрес участка памяти для освобождения: ");
  187.                 scanf("%p", &addr);
  188.                 fflush(stdin);
  189.                 if (!VirtualFree(addr, 0, MEM_RELEASE)) {
  190.                     DWORD err = GetLastError();
  191.                     if (err == ERROR_INVALID_ADDRESS)
  192.                         printf("Ошибка: неправильный адрес\n");
  193.                     else
  194.                         printf("Ошибка: код ошибки %ld\n", err);
  195.                 }
  196.                 break;
  197.             case '3':
  198.                 printf("Возвращаемся в меню\n");
  199.                 flag = 0;
  200.                 break;
  201.             default:
  202.                 printf("Ошибка ввода, попробуйте еще раз\n");
  203.         }
  204.     } while (flag);
  205. }
  206.  
  207. void writeDataByAddress() {
  208.     printf("Введите адрес участка памяти, в который надо записать данные: ");
  209.     LPVOID addr;
  210.     scanf("%p", &addr);
  211.     fflush(stdin);
  212.     printf("Введите данные, которые хотите ввести по указанному адресу: ");
  213.     char buf[MAX_LEN];
  214.     if (fgets(buf, MAX_LEN, stdin)) {
  215.         fflush(stdin);
  216.         buf[strlen(buf) - 1] = '\0';
  217.         LPVOID p = VirtualAlloc(addr, strlen(buf)*sizeof(char), MEM_COMMIT | MEM_RESERVE, PAGE_EXECUTE_READWRITE);
  218.         if (p) {
  219.             memcpy(p, buf, strlen(buf));
  220.             printf("Реальный адрес, по которому переданы данные: %p\n", p);
  221.         }
  222.         else {
  223.             DWORD err = GetLastError();
  224.             if (err == ERROR_INVALID_ADDRESS)
  225.                 printf("Ошибка: неправильный адрес\n");
  226.             else
  227.                 printf("Ошибка: код ошибки %ld\n", err);
  228.         }
  229.     }
  230.     else {
  231.         fflush(stdin);
  232.         printf("Ошибка при считывании ввода\n");
  233.     }
  234. }
  235.  
  236. void setProtect() {
  237.     printf("Введите адрес участка памяти для установки режима защиты: ");
  238.     LPVOID addr;
  239.     scanf("%p", &addr);
  240.     fflush(stdin);
  241.     printf("Введите размер участка памяти для установки режима защиты: ");
  242.     SIZE_T regSize;
  243.     scanf("%I64d", &regSize);
  244.     fflush(stdin);
  245.     DWORD oldProtect, newProtect;
  246.     printf("Введите номер атрибута защиты, который хотите задать:\n"
  247.             "1 - без доступа, 2 - только чтение, 3 - чтение и запись, 4 - исполнение, чтение и запись\n");
  248.     char c = getchar();
  249.     fflush(stdin);
  250.     switch (c) {
  251.         case '1':
  252.             newProtect = PAGE_NOACCESS;
  253.             break;
  254.         case '2':
  255.             newProtect = PAGE_READONLY;
  256.             break;
  257.         case '3':
  258.             newProtect = PAGE_READWRITE;
  259.             break;
  260.         case '4':
  261.             newProtect = PAGE_EXECUTE_READWRITE;
  262.             break;
  263.         default:
  264.             printf("Ошибка ввода, попробуйте еще раз\n");
  265.     }
  266.      
  267.     if (!VirtualProtect(addr, regSize, newProtect, &oldProtect)) {
  268.         DWORD err = GetLastError();
  269.         if (err == ERROR_INVALID_ADDRESS)
  270.             printf("Ошибка: неправильный адрес\n");
  271.         else
  272.             printf("Ошибка: код ошибки %ld\n", err);
  273.     }
  274.     else {
  275.         printf("Проверим с помощью функции VirtualQuery\n");
  276.         PMEMORY_BASIC_INFORMATION memInfo = (PMEMORY_BASIC_INFORMATION)malloc(sizeof *memInfo);
  277.         if (!VirtualQuery(addr, memInfo, sizeof *memInfo)) {
  278.             DWORD err = GetLastError();
  279.             if (err == ERROR_INVALID_PARAMETER)
  280.                 printf("Ошибка: адрес недоступен данному процессу\n");
  281.             else
  282.                 printf("Ошибка: код ошибки %ld\n", err);
  283.         }
  284.         else {
  285.             if (memInfo -> Protect == newProtect)
  286.                 printf("Успешно установлен атрибут защиты\n");
  287.             else
  288.                 printf("Атрибут не был успешно установлен\n");
  289.         }
  290.     }
  291. }
  292.  
  293. int main()
  294. {
  295.     int flag = 1;
  296.     system("chcp 65001");
  297.     do {
  298.         printf("Добро пожаловать! Выберите действие:\n1 - Информация о вычислительной системе\n2 - Статус виртуальной памяти\n"
  299.             "3 - Состояние участка памяти по адресу\n4 - Резервирование (и освобождение) региона и передача ему физической памяти\n"
  300.             "5 - Запись данных в свободную ячейку памяти по адресу\n6 - Установка защиты доступа для заданного региона и ее проверка\n7 - Выход\n");
  301.         char c = getchar();
  302.         fflush(stdin);
  303.         switch (c){
  304.             case '1':
  305.                 getSysInfo();
  306.                 break;
  307.             case '2':
  308.                 getMemoryStatus();
  309.                 break;
  310.             case '3':
  311.                 getStateByAddress();
  312.                 break;
  313.             case '4':
  314.                 regionReserveFree();
  315.                 break;
  316.             case '5':
  317.                 writeDataByAddress();
  318.                 break;
  319.             case '6':
  320.                 setProtect();
  321.                 break;
  322.             case '7':
  323.                 printf("Выход из программы\n");
  324.                 flag = 0;
  325.                 break;
  326.             default:
  327.                 printf("Неправильный ввод, попробуйте еще раз\n");
  328.         }
  329.              
  330.     } while (flag);
  331.     return 0;
  332. }
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
 
Top