hexadecimal para decimal..

alguem pode me dizer pq a 0xffffffff tem representacao -1 ??
tipo eu acho q nao na vida real..mas o programa abaixo diz o contrario..nao sei se isso ocorre no processador ou se fazendo as contas o valor dele eh realmente -1.
alguem poderia me dar uma ajuda nisso????

#include <stdio.h>

int main(void){
unsigned int num = 0xffffffff;

printf("num is %d bits long\n", sizeof(num) * 8);
printf("num = %d (em decimal)\n", num);
printf("num = 0x%x\n", num);
printf("num + 1 = 0x%x\n", num + 1);

return 0;
}

kara testei aq, e oq acontece no seu programinha e q vc esta passando um numero negativo esta usando complemento de 2, os computadores usam complemento de 2 para representar numeros negativos tanto é qndo vc dá

printf("num + 1 = 0x%x\n", num + 1);

ele mostra "0" certo (-1 +1=0 - aritmetica binária hehehehe ), pelo q eu entendi me corrijam se eu estiver errado , complemento de 2 vou explicar mais ou menos porq eu nunca fui bom na facu de eletronica digital mas vai la, para se obter o complemento de 2 de um número precisa pegar esse numero em binário, inverter bit a bit e somar mais ai vc tem o complemento destes numero q é representado pelos microprocessadores e eletronica digital como a representação negativa, tanto é q pega uma HP48g da vida, ou a calculadora do kde mesmo, e testa esta conversão coloca -1 e manda converter pra hexa e ele te mostra este valor certo. espero ter ajudado qualquer coisa to na área

falow

kakaroto

blzaaa!! valeu cara...
eu perguintei a um amigo e ele respondeu o seguinte!!!

"não tenho certeza absoluta mas acho que eh isso:
como vc tem precisão finita na representação de dados, no caso dos inteiros tem um digito de sinal, acho que eles usam um sistemas de anel de inteiros módulo (mais número representável). Por exemplo o anel dos inteiros módulo 3 é
0 - 1 - 2 - 0 - 1 e assim por diante, tem uma forma de representação que usa um bit de sinal. pode ser isso"

provavelmente deve ser isso..eu achei esse programinha numa pagina!!
www.phrack.com ou www.phrack.org. eu estava lendo um txt sobre integer overflow.
se vc puder me indicar um tutorial bom sobre integer overflow fikarei grato..
faloooow
atehh+
[]'s

humm então vc quer dar um overflow na máquina??!!! heheheeh estourando a bit vai um, vc quer estourar um bit do registrador da máquina chamado carry não é isso??, para vc tentar dar um overflow na máquina e estourando a memória, ou estourar tipo assim o limite ou o tamanho da palavra por exemplo os processador 8086 usava regitradores de 16 bits se vc tentar somar um valor alto mais outro valor alto ele vai estourar os 16 bits não serão suficiente para representar o resultado ai o processador seta bit em outro registrador chamado registrador de flags o bit carry dizendo q ouve estouro, putz ja começamos a falar e de eletrônica hehehehe bom se eu estiver errado de novo me corrijam mas axo q é assim ok e oq vc disse não entendi nada, me explica oq quer fazer ok?, oq sei e oq meu professor de microprocessaores disse e q as máquinas usam este esquema de complemento de 2 pega um livro de microprocessadores e lê po, e eu te enviei um txt de como dar um overflow se não der certo me fala q te mando o arquivo ok

falow

kakaroto

consegui gerar um segmentation fault (core dumped)..com integer overflow!
;-)
[]'s
valeu...

BUUAAAAA.....pq q aki eu nunca gero um core dumped???? eu compilo o programa do um overflow (colocando uns 20 caracter onde soh podem 10) ai ele soh fala "Segmentation Fault", eu tenho q estorar a memoria de um intero pra gerar um core dump???? :oops:

hehehe calma calma SDM nao se desespere cara!!!
pra gerar um core eh facil
vc compila o programa da seguinte maneira..

[bash$ ]ulimit -c 1234567

[bash$ ] gcc -o programa programa.c

ae assim q vc der um segmentation fault ele vai gerar um core dump e ae vc analise o core.
eu analiso o core com o gdb
gdb programa

se vc kiser desassemblar o programa vc compila o mesmo da seguinte maneira..
[bash$ ] gcc -o programa -static -ggdb programa.c

soh nao me pergunte o pq doi 1234567 eu ainda nao sei estou procurando saber!
continuando...
ae vc entrando no gdb vc pode ver o seu programa em assembly
eh soh digitar no gdb:

por exemplo para desassemblar a main()
(gdb) desassemble main

para desassemblar a funcao exit() por exemplo
(gdb) desassemble _exit

para desassemblar a funcao execve por exemplo
(gdb) desassemble execve

.................

e assim por diante..espero q fike feliz em gerar um core..
ehehehe
[]'s
falooow cara ateh++
;-)

aaaa entao..falando a respeito da sua outra duvida q eu eskeci..
hehehe..
tipo tem varias maneiras de vc causar overflow (estourar a memoria, ultrapassar a quantidade de dados q sua variavel suporta).
tem, buffer overflow -> quando vc ultrapassa o buffer q seu caractere ou sua string pode suportar.
format string eh outra categoria de overflow - quando vc passa formatação de dados para uma string geralmente quando executa o programa. Essa tecnica geralmente eh aplicada quando vc tem um teste -> if(). para chegar o tamanho a quantidade de caracteres da string mas agora imagine a situacao.

char buffer[8] -> uma variavel do tipo char q suporta 8 caracteres.
ou aproximadamente 8 bytes = 64 bits.
agora vc faz a verificacao com strlen para verificar se a string tem realmente 8 caracteres.
int verifica = strlen(buffer);

o strlen vai atribuir o valor 8 ao verificacao. Mas por tras disso tudo a string buffer[8] vai ter um buffer dentro dela muito maior do q o suportado na realidade..

se vc fosse tentar passar pela verificacao da seguinte maneira
[bash@#] ./prog1 `perl -e 'print "A"x128'` ele nao passaria na verificacao do strlen()

mas agora no nosso segundo exemplo:
[bash@#] ./prog1 %pABC
provavelmente armazenou no buffer uma formatacao para ponteiro e entao o tamnho do buffer serah muito maior do q o suportado. passando pela checagem de strlen com apenas 4 caracteres e um argumento formatado (%p). Se nao ocorrer o segmentation fault eh apenas aumentar o tamanho da formatacao %p..
ficaria assim :
[bash@#] ./prog1 %8pABC
[bash@#] ./prog1 %14pABC

e assim por diante..

esse programinha abaixo vc pode gerar um segmentation fault por format string e gerar um overflow

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int
main(int argc, char *argv[]){

char buffer[8];
int verifica;

if(argc != 2)
{
printf("Sem trapaca\n"); /* apenas para nao haver trapaca */
exit(1);
}

verifica = strlen(argv[1]);

if(verifica <= 8)
{
printf("Ola..muito bem passou pela verificacao\n");
sprintf(buffer,argv[1]);
printf("seu buffer = %s\n",buffer);
}
else
printf("Tente novamente, vc ainda nao consegui estourar o buffer\n");
return 0;
}

alem dessas categorias de overflow ainda tem integer overflow, heap overflow e as q eu nao conheco..
espero ter ajudado..
falooow cara
ateh++
[]'s

po valeu pela ajuda.....ja fonuncio aki.....desculpae ter invadido teu topico :D

q nada cara relaxa...pega nada!!!
;-)
faloow
[]'s
ateh++