Mempercepat Koneksi Smart Selain menggunakan Kodok Loncat

          Setting pengaturan modem seperti di bawah ini :

Smartfren
Profil 1: 
Access number #777 atau *99#
User name: cdma
Password: cdma
Advance setting DNS:
Primary DNS: 8.8.8.8
Secondary DNS: 8.8.4.4

Profil 2: 
Access number #777 atau *99#
User name: smart
Password: smart
Advance setting DNS:
Primary DNS: 208.67.222.222
Secondary DNS: 208.67.220.220

Download Idm v.6.1.1 + keygen


Klik link dibawah untuk download idm :
http://www.internetdownloadmanager.com/download.html

Klik link di bawah untuk download keygen :
http://www.ziddu.com/download/18859458/keygen.krisna.web.id.zip.html

Apabila keygen tidak bisa juga download di sini :
www.remo-xp.com (disini tempat saya belajar juga gan ilmunya bagus" check saja)

Metasploit Part 2

1. Introduction
In the first part of this article series, we discussed how writing exploits is still a painful and time-consuming process. We discussed the common obstacles faced during exploit development and how the Metasploit Framework can solve some of the problems. This article will start off with a brief introduction to the console interface and explain how to select and use an exploit module. We will then cover the environment system, how it works, and what features can be enabled through it.
2. Getting Your Feet Wet
The installed MSF has three work environments, the msfconsole, the msfcli interface and the msfweb interface. However, the primary (and preferred) work area for MSF is the msfconsole. It is an efficient command-line interface that has its own command set and environment system. Although the Framework was designed to run on a Unix-like system, such as Linux or BSD, it will also run on Windows through the Cygwin environment. The Windows installer, from the metasploit.com web site, includes a pre-configured and stripped down version of Cygwin.
During the initialization of msfconsole, standard checks are performed. If everything works out fine we will see the display as shown in Figure 1.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-1.jpg
Figure 1
Now the command prompt (msf>) for msfconsole is active. The console is very flexible, and if the user enters any unknown commands, it will search the PATH environment variable for any matching executable. If a matching file is found it is executed much like a standard command prompt.
Instinctively, typing the help command displays a list of commands available as shown in Figure 2.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-2.jpg
Figure 2
The command show exploits lists out the currently available exploits. There are remote exploits for various platforms and applications like Windows, Linux, IIS, Apache, and so on, which help to test the flexibility and understand the working of MSF. This is shown in Figure 3, below.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-3.jpg
Figure 3
As you may have noticed, the default installation of the Metasploit Framework 2.0 comes with 18 exploits and 27 payloads, which is quite an impressive stockpile.
To list out the payloads present, execute the show payloads command. The payloads are neat, efficient and very well written. These payloads accomplish a wide array of tasks, such as binding a command shell to a listening port, adding new user accounts, or uploading and executing the program of your choice. MSF even has support for dynamic payload creation, using the InlineEgg library as shown in Figure 4.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-4.jpg
Figure 4
Specific information about an exploit can be culled with the command info exploit exploit_name which provides information such as available targets, exploit requirements, details of vulnerability itself, and even references where you can find more information! This is shown in Figure 5.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-5.jpg
Figure 5
In the same manner, information about a specific payload can be gained by the command info payload payload_name. Starting with version 2.2 of MSF, you can use info module_name, without having to specify the type, as shown in Figure 6.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-6.jpg
Figure 6
3. Using An Exploit
Now we will describe the procedure to select a specific exploit and then run it. The command use exploit_name activates the exploit environment for the exploit exploit_name.
If you select the Microsoft RPC DCOM MSO3-026 exploit using the name msrpc_dcom_ms03_026, you may have noticed the prompt changes from msf> to msf msrpc_dcom_ms03_026 >. This notifies that we are working in the temporary environment of that exploit. The show command can be used to view information about the current exploit. The show options command displays the various parameters which are required to be use the exploit, as shown in Figure 7.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-7.jpg
Figure 7
It's clear that this exploit requires two parameters, RHOST (the target's address) and RPORT (and the target's port, defaults to 135 in this case). The show targets command will list all available targets for the selected exploit module. As you can see, this module only has one target, which works on NT 4.0 SP6, plus all versions of Windows 2000, and all versions of Windows XP.
The show payloads command will list all payloads that are compatible with the selected exploit. MSF does a good job of preventing you from using the wrong payload for a given exploit.
We must set each of the options listed as 'required' before we can use this exploit. In this exploit we only have a single target option, so we set the TARGET variable to 0, with the command set TARGET 0. Many exploits will choose a reasonable default target for you. We now set the target server's IP address with the command set RHOST 192.168.0.27.
Next we need to set the required payload (shellcode) for the exploit. Here we set PAYLOAD to winbind, using the command set PAYLOAD winbind. The payload names may change between versions of MSF, so always check the output of show payloads after an upgrade. This particular payload will cause the server to listen on a port and spawn a command shell when a connection is made. This displays the extensible flexibility of the MSF payload system. Every single exploit included in MSF allows for arbitrary payloads to be selected and used, even custom ones you develop yourself. Notice the prompt changes from msf msrpc_dcom_ms03_026 > to msf msrpc_dcom_ms03_026(winbind) > after selecting a payload. Now we use the show options command to check which options have been set and which are required to be set. As we can see, we still need to supply a value for the LPORT variable as shown in Figure 8. We set it using the command set LPORT 1536.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-8.jpg
Figure 8
The EXITFUNC variable is available for almost every Windows payload. This variable controls how the payload will clean up after itself once it accomplishes its task. Quite a few vulnerabilities can be exploited repeatedly, simply by using a different value for EXITFUNC. Fortunately, you rarely have to worry about this as many exploits automatically select the best value for you. Unless you know what you are doing, this value should not set. Setting the wrong value can wreak havoc on the exploited system.
Many exploits and payloads have another set of options, called advanced options. These can be displayed with the command show advanced. Advanced options can perform tasks such as modifying an exploit request to avoid an IDS signature, changing brute force settings, or specifying exact return addresses to use.
At this point, everything is ready and all variables have been set. We make a final check on the exploit with the show options command and verify that we are good to go.
Everything seems perfect. It's show time!
The exploit command actually launches the attack, doing whatever it needs to do to have the payload executed on the remote system.
The check command can be used to whether or not the target system is vulnerable to attack. The check feature is not available with every exploit, but can be useful when you are trying to determine if a system is patched before trying to exploit it.
4. Adding New Exploits/Modules
Adding new exploits to MSF is a breeze. The MSF-compatible remote exploit for IIS 5.x SSL PCT Buffer Overflow was publicly released on 24/04/2004 (http://www.k-otik.com/exploits/04242004.iis5x_ssl_pct.pm.php). For the purposes of this article we will add the exploit to our MSF stockpile.
After downloading the exploit, the user must note the naming of the Perl module for the exploit. The file name must be the same as the package name, in other words, Msf::Exploit::iis5x_ssl_pct should be saved as iis5x_ssl_pct.pm. Now copy the module to the exploits subdirectory (in case you're using Windows it's /home/framework-2.0/exploits). As soon as the file is copied over, it is ready for use, and you do not even need to restart the console. Use the show exploits command to verify that the module has been loaded correctly.

 msf > show exploits Metasploit Framework Loaded Exploits ==================================== apache_chunked_win32       Apache Win32 Chunked Encoding exchange2000_xexch50       Exchange 2000 MS03-46 Heap Overflow ia_webmail                 IA WebMail 3.x Buffer Overflow iis50_nsiislog_post        IIS 5.0 nsiislog.dll POST Overflow iis50_printer_overflow     IIS 5.0 Printer Buffer Overflow iis50_webdav_ntdll         IIS 5.0 WebDAV ntdll.dll Overflow iis5x_ssl_pct              IIS 5.x SSL PCT Overflow imail_ldap                 IMail LDAP Service Buffer Overflow msrpc_dcom_ms03_026        Microsoft RPC DCOM MSO3-026 mssql2000_resolution       MSSQL 2000 Resolution Overflow poptop_negative_read       PoPToP Negative Read Overflow ...
The exploit has been successfully added to the list. The exploit is run in the same way as any other exploit in MSF. Version 2.2 of MSF allows users to keep their own private directory of exploits, payloads, encoders, and nops. Installing a new exploit can be either system-wide, or per-user.
5. Console Environments
In previous paragraphs, we made quite a few references to variables and environments, without explaining what they are. An environment is simply a name space for variables. When you set a variable in MSF, it creates a new entry in your current environment. Environments are used to specify exploit parameters and configure various parts of the system. MSF is divided into two logical environments, the Global Environment and the Temporary Environment. Each exploit, when selected, has a temporary environment which overrides the global environment.
5.1 Global Environment
The global environment is accessed through the setg and unsetg commands. Calling setg displays the current global environment and calling unsetg flushes out all global environment settings.
As shown below in Figure 9, we set the value of LHOST, LPORT and PAYLOAD in the global environment to permanent values and save the changes with the save command.

http://www.symantec.com/connect/sites/default/files/infocus/metasploit2-9.jpg
Figure 9
The save command writes out all the current environments to a file on disk. Versions 2.0 and 2.1 place this data into the file $HOME/.msfconfig, and version 2.2 places the saved environments into $HOME/.msf/config. The saved environments are loaded the next time any of the MSF user interfaces are started. It is common practice to set global environments such as LHOST and LPORT and save them to disk, removing the need to set them on a per-exploit basis.
5.2 Temporary Environment
The temporary environments are sub-environments which override global settings. The Temporary environment is tied to the currently selected exploit. Every exploit's environment is isolated from the rest, allowing the user to easily switch between preconfigured exploits with the use command.
5.3 Advanced Environment Settings
MSF provides quite a few advanced settings which are configured through environment variables. These settings include the logging system, socket options, and debugging parameters.
5.3.1 Logging Options
The logging features can be activated by setting the Logging (global as well as temporary name) variable to a non-zero value. The directory for logs is set by changing the LogDir (global as well as temporary name) variable which defaults $HOME/.msflogs. The msflogdump utility can be used to view the session logs. Starting with version 2.2, the logs are stored in $HOME/.msf/logs.
5.3.2 Socket Options
The various timeout and proxy settings can be changed by setting the following environment variables.
Msf::Socket::Proxies (global name) or Proxies (temporary name): This variable can used to set the proxy (SOCKS4 and HTTP) settings for network connections. It supports proxy chains which can be specified in the format chain type:host:port and is separated by commas for each proxy server.
Msf::Socket::RecvTimeout (global name) or RecvTimeout (temporary name): This specifies the maximum number of seconds allowed for reading from a socket.
Msf::Socket::ConnectTimeout (global name) or ConnectTimeout (temporary name): This is to specify the connect timeout period of a socket (defaults to 10 seconds).
Msf::Socket::RecvTimeoutLoop (global name) or RecvTimeoutLoop (temporary name): Set the maximum time (in seconds) to wait for a connection before the socket is closed. This loop is reactivated at every data receive.
5.3.3 Debugging Options
The environment variable DebugLevel sets the debugging level and the verbosity options for the Framework and modules. The verbosity increases depending on the value of the variable, which ranges between 0 and 5.
5.3.4 Payload Options
By default, the encoding process will cycle through all the modules until it finds one that avoids the particular restricted character set for the current exploit. The precedence of encoding modules can be set in an order separated by commas in the environment variable Encoding. In the same way, the Nop variable is used to specify the nop generating routine precedence. This can be useful when you need to avoid certain IDS signatures.
The RandomNops variable tells the nop generator module to use randomizes sequences of nop-like instructions instead of the standard nop opcode. This can be also be used to avoid IDS signatures. Version 2.2 includes support for smart random nop generation, where each exploit can specify the registers which should not be modified by the nop-like opcodes.
6. Conclusion
After reading the second part of this article, you should have a solid grasp of what the Metasploit Framework is and how you can start using it. We described the msfconsole interface, the general process for selecting and using an exploit, and how environment system works.
This article paves the way for the third and final part of this article series. In part three, we will explain the other user interfaces, the included helper utilities, and some basic guidelines for developing your own exploit modules. We will discuss its future potential by anticipating the new features which will be added to the framework.

Metasploit Part 1 (Ni buat yang belajar metasploit ane dapet dari browsing dan info dari guru ane gan))


sploit(n.)   Exploit. A defect in the game code (see bug) or design that can be used to gain unfair advantages. (Source: Dictionary of MMORPG Terms)
At present the exploit development community (hackers and security professionals alike) is more sentient than ever before. The timeline between the release of an advisory and the development of an exploit has shrunk to a great extent. Exploit development, which was considered more of Wiccan art, has reached large masses. The network security administrator needs to be more vigilant then ever before as the enemy is always one step ahead with the latest exploit in his hand.
Exploit development tools and automated frameworks for exploit testing and simulation is the need of the hour. Metasploit Framework (MSF) is something which fits the bill. Its latest release has the agility and muscle quite comparable to its high priced commercial counterparts and the lethality to code an exploit in the shortest possible timeframe, due to a very well defined interface for development. With a complete exploit environment, working exploits, effectual payloads and added handlers, this is one tool which the penetration testers must utilize.
This article provides an insight into the basics of exploit development frameworks, with a special focus on the Metasploit Framework and how it can be exploited to save time and resources. We describe its usage with graphical illustrations, detail the various commands available, describe features, give practical examples, and most importantly, use these skills to develop new exploits and test out new techniques. The article concludes with elucidating why MSF will influence the future of exploitation in a momentous and positive way.
1. Prologue
I would like to begin my article with reference to some relatively current happenings. The Microsoft advisory (MS04-011) discussed and fixed lot of critical security vulnerabilities in various Windows operating systems [ref 1]. Two of which that interested me were the SSL PCT and Local Security Authority overflows which could lead to remote compromise. As almost immediately, working exploits were released to the public, catching administrators and security professionals unaware and unprepared.
Putting yourself in the mindset of a security administrator in a typical IT company, the exploits added ever more to the existing security burden. Already said and done, this is a wild goose chase where the malicious attacker is ahead of the game, but with a methodical approach the security professional can turn the cards.
Security patches, IDS, firewalls, and so on should not be the only criteria of safety. Succumbing to the pressure of the situation, many nooks and corners of the network can go unprotected and unlatched, which generally become the source of compromise. This is what happens when we hear news about a big network being compromised by hackers using known vulnerabilities. And that's exactly the reason why the Sasser worm hit 250,000 computers, even two weeks after MS released the high-profile security patch.
In my opinion, the solution is the usual, "think like an attacker" approach. The penetration tester should go on a hacking spree by testing his own network, in what I call Threat Evasion Penetration Testing. This is where exploit frameworks come into play, which automate the art of exploitation.
2. Groundwork
Exploits still have a feeling of awe attached to them. Busy pen-testers shrug the idea of exploit development as an idle past time of a hacker. This is in a way true. Exploit development in itself is an art. It requires paramount knowledge, patience, precious time and above all the undying spirit of learning by trial-and-error.
2.1 Memory organization
The basic exploitation techniques can be methodically categorized, like any other technical issue. Before going further, however, the reader must be aware of the basic process of memory organization [ref 2]. A process running in memory has the following sub-structures:

Data and BSS are writable segments containing the static, global, initialized and un-initialized data segments and variables.
Stack is a data structure based on Last-In-First-Out ordering. Items are pushed and popped from the top of the stack. A Stack Pointer (SP) is a register which points to the top of the stack (in most cases). When data is pushed on the stack, SP points to (the top of the stack). Stack grows towards negative memory addresses. It is used for storing the context of a process. A process pushes all its local and dynamic data on to the stack. Instruction Pointer (IP) is a register used to point to the address of the next instruction to be executed. The processor looks at IP each time to find the next instruction to be executed. When an abrupt program redirection takes place (generally due to jmp or call) the address of the next instruction, after returning back from redirection, can be lost. In order to overcome this problem the program stores the address of the next instruction to be executed (after returning from jmp or call) on the stack, and it is called the return address (implemented through assembly instruction RET). This is how a normal program containing many function calls and goto instructions keeps track of right path of execution.
Heap is basically the rest of the memory space assigned to the process. It stores data which have a lifetime in between the global variables and local variables. The allocator and deallocator work to assign space to dynamic data and free heap memory respectively [ref 3].
Code is the read-only segment that contains the compiled executable code of the program.
This was a brief fly-over on the basics of process organization. Now I describe some techniques recurrently used to abuse the harmony of process organization.
2.2 Buffer overflows
The word gives goose bumps to any person who has dealt with them, be it a coder, an application tester or the security administrator. Some say it's the biggest security risk of the decade [ref 4]. The technique of exploitation is straightforward and lethal. The stack of the program stores the data in order whereby the parameters passed to the function are stored first, then the return address, then the previous stack pointer and subsequently the local variables. If variables (like arrays) are passed without boundary checks, they can be overflowed by shoving in large amounts of data, which corrupts the stack, leading to the overwrite of the return address and consequently a segmentation fault. If the trick is craftily done we can modify the buffers to point to any location, leading to capricious code execution [ref 5].
2.3 Heap overflows
The allocated memory in a heap is organized as a doubly linked list. By performing an overflow we can modify the pointers of the linked list to point into memory. Heap overflows are hard to exploit and are more common in Windows as they contain more prominent data which can be exploited. In the case of a malloc memory allocation system, the information regarding the free and allocated memory is stored within the heap. An overflow can be triggered by exploiting this management information such that we can write to random memory areas afterwards, which can lead to code execution [ref 6].
So how is the overflow triggered? There are many weapons in the stockpile like strings and string functions, format strings, null pointers, integer overflows, signed issues and race conditions which can be a help to generate exceptional conditions in a process [ref 7].
I stress the fact that this article was not meant to be a definitive guide to various exploitation techniques. We only provide a quick overview of what is important, in order to get a solid understanding of the things to come in subsequent parts of this article. They just act as pointers for further reference.
3. The Birth of an Exploit
Now comes the most exciting part, coding the exploit. The body or structure of an exploit can be divided into various components, as described in Figure 1 [ref 8]. We describe some exploit miscellany which will help us to analyze the figure as shown.

Figure 1
Figure 1
3.1 Shellcode
This is the payload which is to be executed after exploitation. In most cases we redirect the path of execution so that the injected payload is executed [ref 9]. Hence the return address is made to point to this shellcode. It comprises of assembly instructions encoded as a binary string which perform operations like spawning a shell. A good piece of shellcode must be a trade-off between and size and complexity. There are a lot of verifications to be made during payload encoding like keeping a check on restricted characters. Nowadays, payloads have been customized to be very short and require less space. They can execute many complex operations from opening a listening socket to even loading a compiler on the remote computer.
3.2 Injection vector
The pointer or offset where the shellcode is placed in a process and the return address is modified to point to.
3.3 Request builder
This is the code which triggers the exploit. If it's related to string functions, then scripting languages are generally preferred.
3.4 Handler Routine
This part generally consumes the majority of the code. This is a handler for the shellcode doing operations like linking to a bindshell, or connecting console to a socket.
3.5 User options handler
It is basically a user level front-end providing the user with various control options like remote target selection, offset selection, verbosity, debugging and other options. This forms majority of the exploit code and makes the code quite bulky.
3.6 Network connection Handler
This comprises of the various routines which handle network connections like name resolution, socket establishment, error handling etc.
As we can see there is a lot of unnecessary and repetitive code which makes the exploit really bulky and error prone.
4. Some Common Problems
In the course of development, many problems are faced which hinder the exploit development process. The mad race of people trying to release the exploit first leads to a lot of bad and unnecessarily complicated code.
Some exploits need an understanding of deeper concepts and research, such as exploits based on network protocols (RPC, SMB and SSL) and obfuscated APIs. Also, not much information is revealed in the advisory so there is always the need for experimentation.
Finding target values is also one big headache which involves lot of trial and error.
Finally, most payloads are hard coded and any changes breaks the exploit.
Many firewalls and IPSes detect and block shellcode.
Time is of primary concern, and some exploits consume quite a lot of time and concentration, both of which are the precious assets of a security researcher.
All said and done, coding exploit is one hell of a messy job!
5. Here It Comes!
Enter the Metasploit Framework (MSF)! According to the MSF User Crash Course [ref 10] guide,:

"The Metasploit Framework is a complete environment for writing, testing, and using exploit code. This environment provides a solid platform for penetration testing, shellcode development, and vulnerability research."
In my words, the Metasploit Framework is a singular solution to all the above discussed problems. The framework has matured itself to quite an extent in the 2.0 release version. It's more stable, has very attractive features and a very instinctive user interface for exploit development.
The major features which give an edge to MSF over other options are:

  • It is primarily written in Perl (with some parts in assembly, Python and C), which means clean efficient code and rapid plug-in development.
  • Pre-packaged support for extensible tools, libraries and features like debugging, encoding, logging, timeouts and random nops and SSL.
  • An intelligible, intuitive, modular and extensible exploit API and environment.
  • Highly optimized muti-platform, mutli-featured payloads which are dynamically loadable.
  • Enhanced handler and callback support, which really shortens the exploit code.
  • Support for various networking options and protocols which can be used to develop protocol dependent code.
  • Supplementary exploits are included, which help us to test out exploitation techniques and sample exploits developed.
  • It is Open Source Software and has a dedicated developer community for support.
  • Support for advanced features and third party tools like InlineEgg, Impurity, UploadExec and chainable proxies.
It's clear that MSF is definitely a tool the penetration-tester must get acquaintained with. It gives the art of exploitation a whole new paradigm.
6. Installation
Currently, the Metasploit Framework works efficiently on Linux and Windows. There are some minor compatibility issues, but they can be uncared for. Users can download the latest release for Windows and Linux from http://www.metasploit.com/projects/Framework/downloads.html.
The installation is very trivial and intuitive, and the download packages are in extract and run state. The simple Windows installation is shows in Figure 2. In the case of Linux, decompress the archive (which is in the format framework-2.x.x.tar.gz), where the framework directory contains compiled binaries which are for various utilities. While running on Linux it is advised that Term::ReadLine::Gnu (for tab completion support) and Net::SSLeay (for SSL support) modules be installed (these are found in the extras directory).

Figure 2
Figure 2
The Windows environment is based on a stripped down Cygwin environment, which is a wise solution as it provides a very handy console to the user. However, there were some problems with support of Active State Perl, hence it supports Cygwin Perl only. The installation is packaged as an executable setup, which installs the Metasploit Framework in the specified directory (see figure 2) and adds shortcuts to it.
7. Concluding Part One
In the first part of this article, we did a walk-through of the various exploitation techniques which are frequently being used. We delve into the basics of exploit development and how the exploit code can be broken down into logical sub-structures. We became aware of the major problems plaguing the process of exploit development and how the Metasploit Framework acts as a solution to these problems. We also discussed some of its features and the installation procedure.
In part two we will provide an insight into the various usage and command options, running and adding new exploits, changing environment settings and other advanced features of the Metasploit Framework.

Combine Keyboard Button


1. alt + 1 = ☺
2. alt + 2 = ☻
3. alt + 3 = ♥
4. alt + 4 = ♦
5. alt + 5 = ♣
6. alt + 6 = ♠
7. alt + 7 = •
8. alt + 8 = ◘
9. alt + 9 = ○
10. alt + 10 = ◙
11. alt + 11 = ♂
12. alt + 12 = ♀
13. alt + 13 = ♪
14. alt + 14 = ♫
15. alt + 15 = ☼
16. alt + 16 = ►
17. alt + 17 = ◄
18. alt + 18 = ↕
19. alt + 19 = ‼
20. alt + 20 = ¶
21. alt + 21 = §
22. alt + 22 = ▬
23. alt + 23 = ↨
24. alt + 24 = ↑
25. alt + 25 = ↓
26. alt + 26 = →
27. alt + 27 = ←
28. alt + 28 = ∟
29. alt + 29 = ↔
30. alt + 30 = ▲
31. alt + 31 = ▼
32. alt + 32 = “space”
33. alt + 33 = !
34. alt + 34 = “
35. alt + 35 = #
36. alt + 36 = $
37. alt + 37 = %
38. alt + 38 = &
39. alt + 39 = ‘
40. alt + 40 = (
41. alt + 41 = )
42. alt + 42 = *
43. alt + 43 = +
44. alt + 44 = ,
45. alt + 45 = -
46. alt + 46 = .
47. alt + 47 = /
48. alt + 48 = 0
49. alt + 49 = 1
50. alt + 50 = 2
51. alt + 51 = 3
52. alt + 52 = 4
53. alt + 53 = 5
54. alt + 54 = 6
55. alt + 55 = 7
56. alt + 56 = 8
57. alt + 57 = 9
58. alt + 58 = :
59. alt + 59 = ;
60. alt + 60 = <
61. alt + 61 = =
62. alt + 62 = >
63. alt + 63 = ?
64. alt + 64 = @
65. alt + 65 = A
66. alt + 66 = B
67. alt + 67 = C
68. alt + 68 = D
69. alt + 69 = E
70. alt + 70 = F
71. alt + 71 = G
72. alt + 72 = H
73. alt + 73 = I
74. alt + 74 = J
75. alt + 75 = K
76. alt + 76 = L
77. alt + 77 = M
78. alt + 78 = N
79. alt + 79 = O
80. alt + 80 = P
81. alt + 81 = Q
82. alt + 82 = R
83. alt + 83 = S
84. alt + 84 = T
85. alt + 85 = U
86. alt + 86 = V
87. alt + 87 = W
88. alt + 88 = X
89. alt + 89 = Y
90. alt + 90 = Z
91. alt + 91 = [
92. alt + 92 = \
93. alt + 93 = ]
94. alt + 94 = ^
95. alt + 95 = _
96. alt + 96 = `
97. alt + 97 = a
98. alt + 98 = b
99. alt + 99 = c
100. alt + 100 = d
101. alt + 101 = e
102. alt + 102 = f
103. alt + 103 = g
104. alt + 104 = h
105. alt + 105 = i
106. alt + 106 = j
107. alt + 107 = k
108. alt + 108 = l
109. alt + 109 = m
110. alt + 110 = n
111. alt + 111 = o
112. alt + 112 = p
113. alt + 113 = q
114. alt + 114 = r
115. alt + 115 = s
116. alt + 116 = t
117. alt + 117 = u
118. alt + 118 = v
119. alt + 119 = w
120. alt + 120 = x
121. alt + 121 = y
122. alt + 122 = z
123. alt + 123 = {
124. alt + 124 = |
125. alt + 125 = }
126. alt + 126 = ~
127. alt + 127 = ⌂
128. alt + 128 = Ç
129. alt + 129 = ü
130. alt + 130 = é
131. alt + 131 = â
132. alt + 132 = ä
133. alt + 133 = à
134. alt + 134 = å
135. alt + 135 = ç
136. alt + 136 = ê
137. alt + 137 = ë
138. alt + 138 = è
139. alt + 139 = ï
140. alt + 140 = î
141. alt + 141 = ì
142. alt + 142 = Ä
143. alt + 143 = Å
144. alt + 144 = É
145. alt + 145 = æ
146. alt + 146 = Æ
147. alt + 147 = ô
148. alt + 148 = ö
149. alt + 149 = ò
150. alt + 150 = û
151. alt + 151 = ù
152. alt + 152 = ÿ
153. alt + 153 = Ö
154. alt + 154 = Ü
155. alt + 155 = ¢
156. alt + 156 = £
157. alt + 157 = ¥
158. alt + 158 = ₧
159. alt + 159 = ƒ
160. alt + 160 = á
161. alt + 161 = í
162. alt + 162 = ó
163. alt + 163 = ú
164. alt + 164 = ñ
165. alt + 165 = Ñ
166. alt + 166 = ª
167. alt + 167 = º
168. alt + 168 = ¿
169. alt + 169 = ⌐
170. alt + 170 = ¬
171. alt + 171 = ½
172. alt + 172 = ¼
173. alt + 173 = ¡
174. alt + 174 = «
175. alt + 175 = »
176. alt + 176 = ░
177. alt + 177 = ▒
178. alt + 178 = ▓
179. alt + 179 = │
180. alt + 180 = ┤
181. alt + 181 = ╡
182. alt + 182 = ╢
183. alt + 183 = ╖
184. alt + 184 = ╕
185. alt + 185 = ╣
186. alt + 186 = ║
187. alt + 187 = ╗
188. alt + 188 = ╝
189. alt + 189 = ╜
190. alt + 190 = ╛
191. alt + 191 = ┐
192. alt + 192 = └
193. alt + 193 = ┴
194. alt + 194 = ┬
195. alt + 195 = ├
196. alt + 196 = ─
197. alt + 197 = ┼
198. alt + 198 = ╞
199. alt + 199 = ╟
200. alt + 200 = ╚
201. alt + 201 = ╔
202. alt + 202 = ╩
203. alt + 203 = ╦
204. alt + 204 = ╠
205. alt + 205 = ═
206. alt + 206 = ╬
207. alt + 207 = ╧
208. alt + 208 = ╨
209. alt + 209 = ╤
210. alt + 210 = ╥
211. alt + 211 = ╙
212. alt + 212 = ╘
213. alt + 213 = ╒
214. alt + 214 = ╓
215. alt + 215 = ╫
216. alt + 216 = ╪
217. alt + 217 = ┘
218. alt + 218 = ┌
219. alt + 219 = █
220. alt + 220 = ▄
221. alt + 221 = ▌
222. alt + 222 = ▐
223. alt + 223 = ▀
224. alt + 224 = α
225. alt + 225 = ß
226. alt + 226 = Γ
227. alt + 227 = π
228. alt + 228 = Σ
229. alt + 229 = σ
230. alt + 230 = µ
231. alt + 231 = τ
232. alt + 232 = Φ
233. alt + 233 = Θ
234. alt + 234 = Ω
235. alt + 235 = δ
236. alt + 236 = ∞
237. alt + 237 = φ
238. alt + 238 = ε
239. alt + 239 = ∩
240. alt + 240 = ≡
241. alt + 241 = ±
242. alt + 242 = ≥
243. alt + 243 = ≤
244. alt + 244 = ⌠
245. alt + 245 = ⌡
246. alt + 246 = ÷
247. alt + 247 = ≈
248. alt + 248 = °
249. alt + 249 = ∙
250. alt + 250 = ·
251. alt + 251 = √
252. alt + 252 = ⁿ
253. alt + 253 = ²
254. alt + 254 = ■
255. alt + 255 = “space”