C como imprimir conteúdo da memória

devair1010 · 28 de maio de 2018

olá pessoal estou precisando de uma ajuda e se alguém puder me ajudar fico agradecido desde já .
o que preciso é que estou querendo imprimir o conteúdo do endereço de memória que começa de 2000 em diante ,
até 2500 , e pensei em usar ponteiros para isso , ou se alguém souber um outro jeito pode ser também .

o código que estou tentando é esse aqui :

#include <stdio.h>
#include <string.h>
int main(){
    int cont=0,i;
    volatile unsigned int *ponteiro = (volatile unsigned int *)0x002000;
    for(i=1999;i<2501;i++){
        printf("%d --> %d\n",i,*ponteiro);
        if(cont == 23){
            cont=0;
            getch();
        }
        cont++;
        ponteiro++;
    }
    printf("\n\n");
    return 0;
}

Ansi C · 28 de maio de 2018

Olá ... !

Não é nada diferente de imprimir um vetor, e essa é operação ideal, você já tem a melhor. Só um detalhe 0x002000 > 2000, por motivo das bases .

devair1010 · 28 de maio de 2018

@AnsiC obrigado pela resposta , mas o código que postei não está imprimindo o valor certo, pois ele vai imprimindo de 4 em 4 e não creio que esse seja o valor do conteúdo daquelas posições .

Ansi C · 28 de maio de 2018

@devair1010 Imprimindo de 4 em 4 bytes ou quê?

devair1010 · 28 de maio de 2018

@AnsiC a cada ciclo do laço for o ponteiro seria incrementado em um e ele deveria imprimir o que está naquela posição da memória , mas ele imprime um valor e a cada passada ele aumenta esse valor em 4 unidades . e creio que nessas posições da memória deveria ter valores de zero e no máximo ate 255 .

assim os números em cada posição da memória teria que ser de zero até no máximo 255 . então pelo jeito esse comando não está pegando o valor da memória , e o que preciso é pegar esse valor que está na memória e então qual seria o comando certo para isso .

Ansi C · 28 de maio de 2018

Para imprimir byte a byte então tente assim:

#include <stdio.h>

int main()
{
    char * pbyte = 0x2000;
    while (0x2500 <= pbyte)
            scanf ("%d",* pbyte++);
    // imprimir byte a byte [1 a 1] dos 0x0500 primeiros bytes
    // a partir da célula de memória 0x2000.
    return 0;
}

5 minutos atrás, devair1010 disse:

mas ele imprime um valor e a cada passada ele aumenta esse valor em 4 unidades

Exatamente porque cada inteiro tem 4 bytes, o ponteiro do tipo int obedece essa regra, saltando de 4 em 4 bytes.

devair1010 · 28 de maio de 2018

@AnsiC valeu ! ! ! , mas o código que você mandou não está funcionando , ele passa direto para o final sem fazer nada , e o scanf não seria necessário pois não precisa colocar nenhum valor nessas posições , então seria apenas pegar o que está nessas posições e imprimir .

Ansi C · 28 de maio de 2018

Não percebi que havia escrito scanf

é printf

#include <stdio.h>

int main()
{
    char * pbyte = 0x2000;
    while (pbyte <= 0x2500)
            printf ("%d",* pbyte++);
    // imprimir byte a byte [1 a 1] dos 0x0500 primeiros bytes
    // a partir da célula de memória 0x2000.
    return 0;
}

adicionado 2 minutos depois

Concertei a condição loop também.

adicionado 4 minutos depois

estou usando celular, mas acho que agora vai

vangodp · 28 de maio de 2018

A algum tempo atrás tive lendo sobre isso e terminei por estressar e abandonar o tema, assim que se eu falar alguma bobagem nem liga, é por causa da minha ignorância sobre o tema mesmo, somente pretendo dar a ponta do fio, é você quem tem que desenrolar ele. Beleza? Mas... acredito que não seja possível ter acesso a memória que não pertença ao mesmo programa, o programa "crashearia" ao tentar acessar a memória de outro programa, se um sistema operativo permitisse isso, seria um sistema muito pouco seguro não acha? Os sistemas operativos costumam "blindar" uns programas dos outros para serem mais seguros. Se não me engano, uma vez li que para poder ter acesso a partes da memória de outro programa, esse deve ser um processo filho do mesmo, assim acredito que seja como trabalhe o tal Cheat Engine. Procure por injeção DLL, é algo interessante.

De uma olhada aqui:
https://pt.stackoverflow.com/questions/28377/como-ler-variável-de-outro-programa

Investigue por sua conta e se descobrir algo interessante gostaria de saber também >_<. Se existe alguma forma de lograr isso será a própria API do sistema que o permita fazer, por isso digo que procure sobre injeção DLL, tem muito que ver.

devair1010 · 31 de maio de 2018

@vangodp muito obrigado pela resposta , vou pesquisar nesse site que você passou , se eu descobrir alguma coisa posto aqui o resultado , na verdade o que quero é apenas encontrar e ler a tabela de caracteres básicos que se localiza na rom do pc . mas obrigado pelo interesse e ajuda .

Plástico Bolha · 1 de junho de 2018

Em 28/05/2018 às 00:20, devair1010 disse:

@AnsiC a cada ciclo do laço for o ponteiro seria incrementado em um e ele deveria imprimir o que está naquela posição da memória , mas ele imprime um valor e a cada passada ele aumenta esse valor em 4 unidades . e creio que nessas posições da memória deveria ter valores de zero e no máximo ate 255 .

assim os números em cada posição da memória teria que ser de zero até no máximo 255 . então pelo jeito esse comando não está pegando o valor da memória , e o que preciso é pegar esse valor que está na memória e então qual seria o comando certo para isso .

Cara, você precisa entender algumas coisas como !

Citação

- Modo Real

- Modo pProtegido

- Versões dos Sistemas Operacionais

- Multitarefa

Leia isto:

Citação

Memória Protegida: Usando a multitarefa, quase sempre teremos vários aplicativos carregados na memória, seja na memória RAM ou no arquivo de troca. Se não houvesse nenhum controle por parte do processador, um aplicativo poderia expandir sua área de memória, invadindo áreas de outros aplicativos e causando travamentos no micro.

Um editor de imagens, por exemplo, precisa ocupar mais memória conforme as imagens vão sendo abertas ou criadas. Sem nenhuma orientação por parte do processador, simplesmente seriam ocupadas as áreas adjacentes, que poderiam tanto estar vazias, quanto estar ocupadas pelo processador de textos, por exemplo.

Para colocar ordem na casa, foi desenvolvido o recurso de proteção de memória, que consiste no processador isolar a área de memória ocupada por cada aplicativo, impedindo que ele ocupe outras áreas ao seu bel prazer. Se, por acaso, o programa precisar de mais memória, o próprio processador irá procurar uma área vazia de memória e ordenar ao aplicativo que ocupe a área reservada.

Existem basicamente dois tipos de multitarefa, denominadas multitarefa preemptiva e multitarefa cooperativa, que diferem justamente pelo uso ou não da proteção de memória.

O Windows 3.x, apesar de ser considerado um sistema operacional multitarefa, não é capaz de usar o recurso de proteção de memória, nele é usada a multitarefa cooperativa, que consiste em cada aplicativo usar os recursos do processador por um certo tempo, passar para outro programa e esperar novamente chegar sua vez para continuar executando suas tarefas. A alternância entre os programas neste caso não é comandada pelo sistema e sim pelos próprios aplicativos. Neste cenário, um aplicativo mal comportado poderia facilmente monopolizar o sistema, consumindo todos os recursos do processador por um longo período, ou mesmo invadir áreas de memória ocupadas por outros aplicativos, causando em qualquer um dos casos o famoso GPF, ("General Protection Falt", ou "falha geral de proteção") que tanto atormentava os usuários do Windows 3.x.

Experimente tentar fazer dois irmãos dividirem os mesmo brinquedo; pode funcionar durante um certo tempo, mas uma hora um não vai querer deixar o outro brincar e vai sair briga, exatamente como acontece com os aplicativos dentro da multitarefa cooperativa :-)

O Windows 95/98 por sua vez, usa a multitarefa preemptiva, isolando as áreas de memória ocupadas pelos aplicativos. Isto garante uma estabilidade bem maior do que a que temos no Windows 3.11. Porém, o modo como a multitarefa preemptiva é implementada no Windows 95 assim como do Windows 98 e do Windows Millennium, que são baseados no mesmo kernel (núcleo) do Windows 95, ainda possui dois problemas graves:

O primeiro é que, quando é executado um programa de 16 bits, o Windows 95 cai em multitarefa cooperativa para poder rodar o programa, deixando de proteger as áreas de memória e tornando-se tão vulnerável quanto o Windows 3.11.

Porém, mesmo usando apenas aplicativos de 32 bits os travamentos ainda são comuns, pois o Windows 95 os serviços do sistema não tem prioridade sobre os aplicativos. Isto significa que caso um aplicativo qualquer entre em loop, poderá consumir todos os recursos do processador, neste caso o sistema operacional ficará paralisado, simplesmente sem ter como fechar o aplicativo e restaurar o sistema, obrigando o usuário a resetar o micro e perder qualquer trabalho que não tenha sido salvo. Na verdade costuma-se dizer que o Windows 95/98 utiliza multitarefa semi-preemptiva, pois não utiliza todos os recursos de uma verdadeira multitarefa.

A solução para este problema veio com o Windows NT. Desde suas primeiras versões, o Windows NT é bem estável neste aspecto, pois implementa a multitarefa preemptiva de forma completa. As tarefas executadas pelo sistema operacional, são priorizadas sobre as de qualquer outro aplicativo. Isto significa que em nenhuma situação, um aplicativo terá como passar por cima do sistema operacional e consumir todos os recursos do processador como acontece no Windows 95/98.

Na prática, significa que o sistema até pode travar devido a algum bug, mas se algum aplicativo travar ou tentar invadir uma área de memória não designada para ele, simplesmente será fechado, permitindo que todos os demais aplicativos continuem trabalhando sem problemas. Você logo notará quais aplicativos costumam dar problemas, bastando substituí-los por versões mais recentes que corrijam seus bugs ou mesmo passar a usar um programa concorrente.

Tanto o Windows 2000, quanto o XP são baseados no kernel do Windows NT e mantém o mesmo sistema de funcionamento. Por ter sido inspirado no Unix, o Linux utiliza multitarefa preemptiva desde suas primeiras versões, é por isso que o Linux é considerado um dos sistemas mais estáveis, a ponto de ser usado em vários dos mais importantes servidores do planeta.

O MacOS por sua vez, utilizou a multitarefa cooperativa durante muito mais tempo, até a versão 9.x. Os usuários dos Mac só passaram a ter disponível um sistema com multitarefa preemptiva a partir do MacOS X, que é baseado no FreeBSD, um sistema Unix de código aberto, semelhante ao Linux em vários aspectos. A Apple usou o FreeBSD para construir o Darwin, que é a base do sistema e completou a obra com a interface Aqua, que mantém a ideia de facilidade de uso das versões anteriores do MacOS.

Modo Virtual 8086: Apesar de, operando em modo real, o processador ser totalmente compatível com qualquer programa antigo, seria impossível executar um aplicativo de modo real dentro do Windows 95 ou qualquer outro sistema operacional que utilize o modo protegido. Seria preciso fechar o Windows e fazer o processador voltar para o modo real para poder executar o aplicativo.

Pensando nesta possível limitação, os projetistas da Intel desenvolveram o modo virtual 8086 onde o processador, operando em modo protegido, é capaz de simular vários ambientes de modo real, cada um com 1 MB de memória e total acesso ao hardware do micro, chamados de máquinas virtuais. É como se dentro do 386 fossem abertos vários XTs completos, um para cada programa de modo real a ser executado. É justamente o modo virtual 8086 que permite abrir janelas DOS dentro do Windows 95/98.

Como o processador continua em modo protegido, cada máquina virtual tem sua área isolada na memória. O programa roda sem prejudicar a estabilidade do sistema.

Caso você queira fazer testes simulando acesso total a memoria, ou seja, acessar o que você quiser, quando quiser e alterar ou ler o endereço de memoria que quiser, recomendo você utilizar o "DosBox", aí sim você vai conseguir sair fora da caixa de verdade !

OBS: Quando você cria um processo feito em C/C++ seja lá a linguagem que for, você está dentro de uma caixa, onde os S.Os "modernos" criam pra sua caixa endereços de memória relativos ! E você pode operar ali dentro, se quiser acessar endereços fora dessa caixa , DLLs são uma opção ... No entanto imagina só se o S.Os modernos deixassem você criar um processo que pude-se ler/escrever em endereços de memória fora do seu processo ! Seria o caos ... Nos tempos antigos de IBM PC isso era permitido, e deu muito errada hahah ... Tipo eu crio um programa que altera o endereço do bootloader do teu PC ... Pronto matei teu HD, você não inicia mais o PC =D ...