Gamerz Online

La principal diferencia es la velocidad en el procesador, una netbook esta orientada a conectarse a internet y correr aplicaciones sencillas como una hoja de calculo o el procesador de palabras. No cuentan tarjeta gráfica y no se les puede poner, por lo general ni siquiera tienen unidad de cd, por lo cual, olvidate de correr juegos en una maquinita de estas por que su capacidad es enserio limitada, y su memoria RAM es maximo expandible a 2Gb.
La otra cosa es que son muuuy pequeñas, su pantalla es de 9" por lo que si la quieres para jugar vas a terminar ciego. Y para escribir el teclado es muy pequeño, muy incomodo.
No es por desanimarte, pero si quieres un equipo para jugar, mejor junta para buena lap com tarjeta aceladora, buen procesador y unos 4Gb de memoria, o mejor compra o arma un pc de escritorio, son mas baratas y tan expandibles como quieras

Pues mirasi quieres una computadora para usar juegos primero debes estar conciente que los juegos son una de las aplicaciones q mas recursos itilizan en una computadora por lo que te recomiendo consideres esto y decidas lo que te combiene:
El tamaño del netbook es mucho más pequeño que su primo cercano, el notebook o laptop. La mayoría de los netbooks tiene una capacidad menor, con la memoria como el componente que más sufre.
Algunos ultralivianos poseen apenas 8GB de disco duro y también hay modelos hasta 160GB. La batería puede tener menos duración y la mayoría no cuenta con unidad óptica.
Otra razón es que hay varios netbooks están diseñados para personas que sólo quieren un computador portátil para navegar por Internet o escuchar música. La principal diferencia entre netbooks y notebooks radica en el objetivo de uso de ambos equipos
Los Netbooks fueron concebidos especialmente para expandir la computación principalmente en el área de educación. Esta plataforma, además de navegar por Internet, mail y voz sobre IP, permite la ejecución de aplicaciones básicas y tareas personales, tales como ver videos, fotos o escuchar música", detalló por una parte. En cambio, el ejecutivo nacional consideró que los notebooks son dispositivos con la más alta performance y posibilidades de ejecución en las tareas más avanzadas. Netbooks pueden parecer como laptops, pero no tienen todas las capacidades de un computador. Como se aseguró, son más útiles para tareas en Internet combinada con una gran transportabilidad, ya que su peso es casi la mitad de un laptop normal. Así que es muy bueno para tener como apoyo al PC principal.
Por ejemplo, el Asus EEE netbook tiene una resolución de 800x480, muy bajo para el estándar en el cual está convertido el 1280x1024. Por lo tanto las posibilidades gráficas de este dispositivo son limitadas.
Esto ha llevado que mucha gente piense que los netbooks son un retroceso hacia antiguos modelos que tenían este tipo de prestaciones y que gracias a su precio han renacido en el mercado.


En general las diferencias son las sig:
___Laptop_________________Notebook
1.-Tamaño mayor_________Tamaño aproximado a un cuaderno(notebook)
2.-Peso mayor____________Peso menor
3.-Puedes actualizar el procesador generalmente__No se puede
4.-Puedes tener graficos dedicados___Generalmente no
5.-Tienen unidad de disco optica integrada___Generalmente no debido a espacio y peso.
6.-Mas resolucion en pantalla desde 1280x800 hasta 1920 x1080__hasta 1280X800

Te recomiendo una laptop con graficos dedicados si es que la quieres para jugar videojuegos

Las Laptops también conocidas como las computadoras portables o portátiles cada día son mucho mejores y tienen muchas divisiones como lo son las: Notebooks, Netbooks y Netbooks Mini. ¿Quieres enterarte de la diferencia entre ellas y de sus funciones?

Para disipar muchas dudas de usuarios y visitantes de Tecnología y Gadgets quiero aclarar aspectos y características, así como las definiciones personales y diferencias entre laptops que considero correctas.

¿Qué es una Laptop?

También conocida como computadora portátil, ordenador portátil, entre otros, es como lo dice su nombre una computadora con la capacidad de ser portable, es una computadora personal de ligero peso y con la potencia y capacidad de una computadora común o básica de escritorio.

¿Qué es una NoteBook?

Una NoteBook es una computadora portátil con capacidades muy potentes por lo común más pesada y grande que una Netbook, pero con la ventaja de tener una pantalla más grande y un procesador mejor.

¿Qué es una Netbook?

Una NetBook es una computadora portátil con capacidades niveladas y su punto fuerte se basa en su portabilidad, pues es más pequeña, menos pesada y en ella han sido eliminados ciertos componentes para hacerla más portable y más económica, por eso han sido las computadoras portátiles que más fuerza han tomado en el mercado.

¿Qué es una NetBook Mini?

Una Netbook Mini o Mejor conocida como “Laptop Mini”, es una computadora portátil con capacidades muy básicas, pero con la ventaja de tener un precio bastante económico, la principal desventaja suele ser su procesador y el tamaño de su pantalla, sin embargo están tomando fuerza en el mercado.

---

---

[TUTORIAL] Everything you need to know about Hooking
Author:OsGB'
Tutorial:

In essence there are only 2 types of hooks;

1) User Level Hooking
2) Kernel Level Hooking


of course there are so many things that fall into place between those 2 things that the remaining types of 'sub' hooks are just gravy.


Win32 API Hooking falls under User Level hooking (user level, application level, os level -- et al)
API Hijacking is the easiest to do although very complex for a newcomer

here are a few things you can do at User Level Hooking:

Window subclassing.

One of the most simplistic hooking methods is sublcassing a window, after this is done a user can do a lot of things such as modify keyboard and mouse input/output, do events when certain input is given, etc...

A HWND Proc Hook is an example of a way to subclass a windows application and grab all of the input that a user sends it (keyevents, mouse, et al)

The only thing bad about Subclassing is that you are constricted to that single application and it is therefore not a system wide at all


Proxying

You find this to be common in wrappers, basically its when a user replaces a dll with their own that has the same amount of names and exports all of the functions/symbols that the original would

Function fowarding and hooking the exports of a dll is a simple process and is something that you saw me explain earlier in my first post, a simple example of proxying code used in a GL Wrapper:





Since the opengl32.dll is loaded automatically (as a proxied dll - a wrapper) that in essence 'wraps' the render device of opengl, it will do everything you tell it to do.
as you can see in the Hooked_glBegin function it does everything you tell it to do and THEN calls back to the original function so as to not **** things up :]

proxying is one of the easier ways to hook functions and can even be system wide if done in certain modules.


Code Overwritting / Detouring

Oh this is fun! this requires asm > Code overwritting can be a very complicated and messy concept but if it works, it works good. (although its buggy and prone to error out A LOT so... its not a fun process, and its not garunteed to work since its not static like function forwarding through a lib or subclassing can be)
There are a lot of ways you can overwrite code or detour, all are very powerful, all are very 'Toolly' but efficient. A simple example of code overwritting is what we used to do long ago with Byte of uscript packages.



overwritting is as simple as byte in that case where you can change Destroy to - Firealt, or == to !=, or you to him, or hax0r to l3git...

Just as there are a lot of possibilities in a simple byte there are also a lot of possiblities in API hooking using overwritting.

1 way of overwritting is to replace the address of the function when it is "CALL"ed



lets take a crash course in Reverse Engineering 101:

as we can plainly see thats a call to DllMain which every dll prog needs, and since im a super leet hax0r i know what DllMain is composed of;
now let me get back to what i was saying each one of the above asm instructions has an 'address' in memory
the first instruction of:
PUSH EBX is located at 0x105E189F in Engine.dll
PUSH ESI is 0x105E18A0
PUSH DWORD PTR SS:[EBP+8] is 0x105E18A1
and the call to DllMain is 0x105E18A4


now your probably wondering why is it that it was incremental from 0x105E189F + 1 =
to 0x105E18A0 + 1 =
to 0x105E18A1 + 3????? =
that makes sense right? thats just going up by 1 each time.... but whats this?
the call to DllMain is at 0x105E18A4???
why did it jump 3 entire bytes, did it **** up some how?

no it didnt heres why:

In order to call a function one must first push all of its params (registers) to the stack, params are pushed backwards (DONT EVER FORGET THIS):

so in the case of DllMain, you have 3 params:
DllMain(HMODULE hDll, DWORD Reason, PVOID lpReserved)
1) lpReserved = DWORD PTR SS:[EBP+8]
2) Reason = ESI
3) hDll = EBX

now look:


each of the above look like this in Hex:
translate that back to english:
now to explain why it jumps 3 bytes from 0x105E18A1 to ( +3 = ) 0x105E18A4

0x105E18A1 = FF75 08

0xFF = 1 byte
0x75 = 1 byte
0x08 = 1 byte

1 + 1 + 1 = 3

0x105E18A1 + 3 = 0x105E18A4

makes sense now? I hope so.



Onward again to how one actually HOOKS that "CALL" of DllMain (this isnt a smart idea, but just a proof of concept, dont go trying to hook the programs entry point......)


remember how:
0xE8 0xF796DBFF
=
(F796DBFF)Engine._DllMain@12

well what if we wanted to call "MyHax0rDllMain" instead

well thats easy, we would do this:
0xE8 0xOFFSETOFOURFUNCTION



You can do this one of 2 ways, if your just Tooling the dll itself with its own code (ie byte) - fyi; you CAN byte a dll/exe, its very possible, you need to know asm.

1) Byte the File: you could tell it to JMP to another area in the dll instead of Calling DllMain, of course it would crash but if you knew what you were doing it wouldnt crash you could make it do what you want.

2) Editing Memory: Remember the old md5 Tool for 2k4 that Clockwize released? Welcome back to the hell of trying to read over that source, but maybe this time you'll understand what it was doing.

its doing exactly what i showed above^- just its doing it on the fly so it has to protect the memory and protect the registers otherwise the computer will freak out and scream "WTF ARE YOU TRYING TO DO, YOU CAN NOT VIOLATE ME WHEN I AM TRYING TO RUN A PROGRAM! OMG RAPE"

code snippets;

Now that you have the Location loaded into a Pointer you can use in your source you can VirtualProtect the next 5 bytes in memory

why 5?

0xE8 0xF796DBFF
0xE8 = 1
0xF7 = 1
0x96 = 1
0xDB = 1
0xFF = 1

1 + 1 + 1 + 1 + 1 = 5

fill all 5 bytes with NOPS:


Protect your registers so you dont **** up the stack!!!
__asm pushad ; push all registers
// do what you want here:
// in our case we shall:
__asm call MyHax0rDllMain


reset the registers again!

__asm popad

TADA YOUR DONE

thats several methods of Code Overwritting and 1 example of Detouring!
/me whipes sweat off forehead


Breakpoints via Debugger

breakpoints own! ok well sorta... they are great in so many ways but not (in my opinion) for hooking
debuggers give you an easy way to make use of them

A breakpoint stops (pauses) a program for an extended amount of time to give you the user time to do whatever you wish with the memory that you broke at without ****ing up the program

There are a few drawbacks to using this approach though as debugging a prog will suspend all application threads (will ... physically pause the program)
uh not the best hax0r method...

can also be done through code, too much of a waste to explain


Altering the IAT (Import Address Table)

This is a very clean and efficient way to hook almost anything, if you saw my Unreal Engine Hook tutorial you will see an example of Import Address Table hooking.

In order to make good use of IAT hooking you need to know a good deal about the Portable Executable (PE) Windows File Format and Common Object File Format (COFF)

The most important of the 2 however is the PE File Format, the PE file format is composed of 7 sections, just like our unreal file format is composed of certain things (Header, Name Table, Imports, Exports)

the most important part of the PE File Format is ".idata" .idata is in essence the Import Table and all of the data within it. When a program/module is made it has a lot of 'dependancies' just as our Tools have dependancies in say; 'engine' and 'core' -

Each dependancy in a Win32 application is called an Import (same as uscript)

The best way to determine all of the Imports of a application is to grab information (in an infinite loop) out of .idata - one would think that scanning through all of the imports of an application would bog down the hooking process and take considerable system resources, but thats what is so lovely about IAT, every import of said win32 application is located neatly and cleanly within the Import Address Table! Because it's just that, a Table, with offsets Imports and data, each one composed of nothing more than an indirect call to an import that is 'written' into the IAT with a simple JMP

Scan through .idata, find the function (offset, thunk, et al) that you want ->
and VirtualProtect it again - initalize your typedef and fill it with all the information from what the IAT points to and TADA you just hooked a win32 API Function in the most clean and efficient manner to date (imo)

heres a code snippet for ya'll who havent looked at my source:



called with:

:]


Now that I got that all aside I will just tell you briefly what Kernel Level hooking is and why you should NOT attempt to do it unless you REALLY know what your doing:

The great thing about playing at the Kernel level is that you have free roam to do whatever the **** you please, every winapi function that is called at a User Level or even higher (OS etc) will pass through Kernel, you have access to it ALL - the only thing you might piss off is an AntiVirus or 2, anticheats cant do SHIT about kernel level romping, shit a stick- anticheats cant do much about USER LEVEL hooking, so you can only IMAGINE how impossible it would be for an anticheat to do much of anything when you play with the kernel

The easiest way (hah easy) to achieve kernel level romping is to do one of the following:

1) get the Win DDK for your respective OS, start reading --- and make simple hooks of shit that you find in ntdll (the resultes of this are monumental as I have seen in almost every game I have Tooled using Kernel level hooks with this
method) and its not overly hard to do!

2) Write your own Device Driver
hang on let me sit back for a minute and say
R O F L

yeah... ok thats done. p1p0 is doing that right now and is coming out VERY succesfull, mad ****ing props to him for making the impossible possible! (and at such a young age! insanity >_
3) RING0

lol...

if you know what ring0 is you know why i just laughed
I played there but let me tell you this, **** up once and you will surely see the entire system DUMP and DIE with a BLUE SCREEN OF DEATH

so uh, dont make mistakes :]

ever seen several BSOD's on a NT System in 1 day? I have, its a very disturbing sight

When i was toying with ring0 there was barely ANY documentation out there, and still to this day documentation is severely lacking... if you want to know more about ring0 you can talk to me personally or i HIGHLY suggest you read what this site has to offer:
--- and read ALL of the links he provides, your lucky you can find ANY information on the insides of NT but its there, read!

---

---

CreateRemoteThread .dll Injection

---