Dewasa ini terasa begitu sulit untuk mendapatkan pekerjaan yang menjanjikan income besar, dan bahkan dalam kenyataannya banyak terjadi PHK dimana-mana. Apakah ada solusi untuk menghadapi hal yang demikian ???
Welcome to my another tutorial of PHP and MYSQL. In the previous tutorial I've briefly discussed How to make a PHP file and How to save the PHP file in the root directory of the server. How to run PHP script over the Web Browser etc.
Now in this tutorial I've discussed about inserting data into database by getting the values from user with the help of HTML form. One thing should be remembered that getting a values from users by HTML form is the only way to get values from users in PHP.
How To Insert Data into Database
Step 1:
Open your text editor and create HTML form.
Step 2:
Make a database connection in PHP.
Step 3:
Write an INSERT query for the sake of insertion data into database like INSERT INTO table_Name(table_Attribute1, table_Attribute2....) VALUES('1', 'Alex'...); etc. Now watch the video to make a better understanding the concept of insertion.
Information gathering can be broken into seven logical steps. Footprinting is performed during the first two steps of unearthing initial information and locating the network range.
Footprinting
Footprinting is defined as the process of establishing a scenario or creating a map of an organization's network and systems. Information gathering is also known as footprinting an organization. Footprinting is an important part of reconnaissance process which is typically used for collecting possible information about a targeted computer system or network. Active and Passive bothcould be Footprinting. The example of passive footprinting is assessment of a company's website, whereas attempting to gain access to sensitive information through social engineering is an example of active information gathering. Basically footprinting is the beginning step of hacker to get hacked someone because having information about targeted computer system is the main aspect of hacking. If you have an information about individual you wanna hack so you can easily hacked that individual. The basic purpose of information gathering is at least decide what type of attacks will be more suitable for the target. Here are some of the pieces of information to be gathered about a target during footprinting:
Domain name
Network blocks
Network services and applications
System architecture
Intrusion detection system
Authentication mechanisms
Specific IP addresses
Access control mechanisms
Phone numbers
Contact addresses
Once this information is assemble, it can give a hacker better perception into the organization, where important information is stored, and how it can be accessed.
Footprinting Tools
Footprinting can be done using hacking tools, either applications or websites, which allow the hacker to locate information passively. By using these footprinting tools, a hacker can gain some basic information on, or "footprint," the target. By first footprinting the target, a hacker can eliminate tools that will not work against the target systems or network. For example, if a graphics design firm uses all Macintosh computers, then all hacking software that targets Windows systems can be eliminated. Footprinting not only speeds up the hacking process by eliminating certain tool sets but also minimizes the chance of detection as fewer hacking attempts can be made by using the right tool for the job. Some of the common tools used for footprinting and information gathering are as follows:
Domain name lookup
Whois
NSlookup
Sam Spade
Before we discuss these tools, keep in mind that open source information can also yield a wealth of information about a target, such as phone numbers and addresses. Performing Whois requests, searching domain name system (DNS) tables, and using other lookup web tools are forms of open source footprinting. Most of this information is fairly easy to get and legal to obtain.
Footprinting a Target
Footprinting is part of the preparatory pre-attack phase and involves accumulating data regarding a target's environment and architecture, usually for the purpose of finding ways to intrude into that environment. Footprinting can reveal system vulnerabilities and identify the ease with which they can be exploited. This is the easiest way for hackers to gather information about computer systems and the companies they belong to. The purpose of this preparatory phase is to learn as much as you can about a system, its remote access capabilities, its ports and services, and any specific aspects of its security.
DNS Enumeration
DNS enumeration is the process of locating all the DNS servers and their corresponding records for an organization. A company may have both internal and external DNS servers that can yield information such as usernames, computer names, and IP addresses of potential target systems.
NSlookup and DNSstuff
One powerful tool you should be familiar with is NSlookup (see Figure 2.2). This tool queries DNS servers for record information. It's included in Unix, Linux, and Windows operating systems. Hacking tools such as Sam Spade also include NSlookup tools. Building on the information gathered from Whois, you can use NSlookup to find additional IP addresses for servers and other hosts. Using the authoritative name server information from Whois ( AUTH1.NS.NYI.NET ), you can discover the IP address of the mail server.
Syntax
nslookup www.sitename.com
nslookup www.usociety4.com
Performing DNS Lookup
This search reveals all the alias records for www.google.com and the IP address of the web server. You can even discover all the name servers and associated IP addresses.
Understanding Whois and ARIN Lookups
Whois evolved from the Unix operating system, but it can now be found in many operating systems as well as in hacking toolkits and on the Internet. This tool identifies who has registered domain names used for email or websites. A uniform resource locator (URL), such as www.Microsoft.com , contains the domain name ( Microsoft.com ) and a hostname or alias ( www ). The Internet Corporation for Assigned Names and Numbers (ICANN) requires registration of domain names to ensure that only a single company uses a specific domain name. The Whois tool queries the registration database to retrieve contact information about the individual or organization that holds a domain registration.
Using Whois
Go to the DNSStuff.com website and scroll down to the free tools at the bottom of the page.
Enter your target company URL in the WHOIS Lookup field and click the WHOIS button.
Examine the results and determine the following:
Registered address
Technical and DNS contacts
Contact email
Contact phone number
Expiration date
Visit the company website and see if the contact information from WHOIS matches up to any contact names, addresses, and email addresses listed on the website.
If so, use Google to search on the employee names or email addresses. You can learn the email naming convention used by the organization, and whether there is any information that should not be publicly available.
This morning I've found an scaring surprise on my Firefox Quantum. Casually it was connected to a proxy when an unexpected connection came up, the browser was connecting to an unknown remote site via HTTP and downloading a ZIP that contains an ELF shared library, without any type of signature on it.
This means two things
1) the owner of that site might spread malware infecting many many people. 2) the ISP also might do that.
Ubuntu Version:
Firefox Quantum version:
The URL: hxxp://ciscobinary.openh264.org/openh264-linux64-0410d336bb748149a4f560eb6108090f078254b1.zip
The zip contains these two files: 3f201a8984d6d765bc81966842294611 libgmpopenh264.so 44aef3cd6b755fa5f6968725b67fd3b8 gmpopenh264.info
The info file: Name: gmpopenh264 Description: GMP Plugin for OpenH264. Version: 1.6.0 APIs: encode-video[h264], decode-video[h264]
So there is a remote codec loading system that is unsigned and unencrypted, I think is good to be aware of it.
In this case the shared library is a video decoder, but it would be a vector to distribute malware o spyware massively, or an attack vector for a MITM attacker.
In this chapter we will take a look at bypassing incorrectly coded value transaction patterns within Ethereum smart contracts. These incorrectly coded patterns can lead to Reentrancy attacks that ultimately allow an attacker to liquidate the contract of all of its funds without much effort. The incorrect order of operations allows an attacker to avoid require statements which check if a user's balance is high enough to send a transaction. We can use this to bypass incorrect logic patterns and drain a contract of its funds.
Reentrancy attacks allow an attacker to create a loop between a target contract and a malicious attacker owned contract. Instead of a normal user making a request, the request comes from the attacker's contract which does not let the target contracts execution complete until the evil tasks intended by the attacker are complete. Usually this task will be draining the funds out of the contract bit by bit until all of the contracts funds are transferred to the attacker's contract.
The checks effects interactions pattern is a secure coding pattern within Solidity on Ethereum which prevents an attacker from re-entering a contract over and over. It does this by ensuring that balances are updated correctly before sending a transaction. It does this by:
üChecking that the requirements are met before continuing execution.
üUpdating balances and making changes before interacting with an external actor
üFinally, after the transaction is validated and the changes are made interactions are allowed with the external entity
The incorrectly coded pattern that usually creates a vulnerable smart contract is the common sense approach that first checks if a user's balance is large enough for the transaction, then sends the funds to the user. Once the transaction goes through, without error, the amount is subtracted from the user's balance.
The problem is that if a hacker's contract calls the target smart contract rather than a valid user calling the contract, the hacker's contract can run code in a loop. The hacker can call the same function in the target contract again without ever reaching the code that subtracts from the user's balance. This means that the initial balance check that passed the first time will pass again and again and again because it is at the same balance that passed the first time. You see where this is going right? The transaction will continue until the balance for the whole contract is empty, rather than just the users balance. Let's take a look at a simple example in order to understand how this works.
19.function getBalance() public view returns (uint){
20.return balances[msg.sender];
21. }
22.}
Simple Reentrancy Target Analysis Video:
There are three functions in the above contract, but the one we need to pay special attention to is the one that interacts with outside users. The withdraw function sends funds to the address of the user who called the withdraw function. This would be classified as an interaction and needs to follow our secure pattern.
The line breakdown of the withdraw function is as follows:
üLine 12: Checks that you are only withdrawing the amount you have in your account or sends back an error.
üLine 13: Sends your requested amount to the address the requested a withdrawal.
üLine 15: Deducts the amount withdrawn from the accounts total balance.
üLine 16. Simply returns your current balance.
Based on the above breakdown this function is following a:
Checks à Interaction à Effects
which violates the
Checks à Effects à Interactions
Because we interact with an external entity prior to updating the effects, the target contract is at risk for a call by a malicious contract that executes a loop with a malicious purpose.
Essentially what will happen is that the attacker will use his own malicious contract to call the withdraw function after adding a small value to his account. When the withdraw function is called the attackers contract will attempt to withdraw a smaller amount then the attacker has in his account which will pass the Checks portion of the pattern on line 12.
Next the target contract will attempt to interact with the attacker's contract by sending the valid withdrawn value from the contract. However, the attacker will have a fallback function that receives the sent value and calls the withdraw function again.
The second time calling the target contract will result in the exact same checks and interaction without ever updating the balance via the Effects portion. Over and Over and Over again.
The Effects portion will only be updated after the attacker's loop ends and the damage is done. Which means that the attacker has withdrawn funds many times over, but only subtracted that value a single time. Potentially draining all of the funds of the contract.
If we take a look at the following attacker's contract, we will see how the attacker creates this loop and we can analyze the order of operations that makes this possible.
The attacking code above is used by the attacker to siphon funds from a vulnerable contract. The main attack code in this contract is found on lines 22-24. This code creates a looping condition into the other contract by using a fallback function.
What is a fallback function?
A fallback function is a default function in a contract that is called when no other function is specified. So, in this instance when the contract receives funds and no other directions from the withdraw function, then the fallback function will execute on line 22. The fallback function will check that the target contract still contains a balance larger then what we are requesting which is defined on line 8 as "1 Ether".
If this check passes then our contract calls back into the withdraw function again at line 24. Which starts the whole process over and over again until the balance of the target contract is less than 1 ether. Let's take a look at a graphical representation of this to help understand what's going on.
The picture above shows the target contract and the attackers contract side by side. The attack function calls into the withdraw function initially. Then the fallback function is entered from the withdrawal transaction and returns right back to the beginning of the withdraw function from the fallback functions call back into the contract. This forms the loop between withdraw and fallback until the contract is below 1 ether.
That explains the main attack portion of the contract. The other parts of this attacking contract are just helping setup for the attack for example the interface code at line 1 simply creates an interface into the target contract via its function definitions. This interface is then set to the address of the target contract on line 7. With this interface you can now call the functions directly with the bankAddress interface using the function name as seen in the deposit function and attack function to call deposit and withdraw.
There is one other function we didn't mention which has nothing to do with the attack but helps us claim our funds after the contract is sent the ether from the attack. This function is on line 18 named retrieveStolenFunds. It simply takes the balance of "this" contract and transfers it to our personal address.
Let's try attacking the banking contract to see Reentrancy in action. Type out the code above for the target contract and understand what each piece of the contract does. Then type out the attacker's contract and try to piece together what each part of the attack does and what the sequence of execution will be.
Note: It's important that you type out this code and do not copy paste as it will help you in spotting issues in the future and your understanding of how things work.
Action Steps:
üWith account 1 deploy the target simpleReentrancy contract
üDeposit 20 Ether into the account by adjusting the Value field and selecting Ether
üCopy paste the address of the target contract and enter it into the target Interface variable in the attackers contract
üDeploy the attacker's contract simpleReentrancyAttack contract
üDeposit 2 ether into your account using the attackers contract deposit function
üThen execute the attack function with the attack button
üWhy did it pause?
üWhen attack completes execution note your second accounts balance and click retrieveStolenFunds
üNote your new balance
After running the attack, you should have noticed that your balance was updated by roughly 22 ether give or take fees. This would be the balance of the target contract initially and your own balance returned. You would have also noticed a pause when you clicked attack. This is because you are waiting for the contracts loop to complete its execution. It was calling the contract over and over again until 22 times.
Exploiting Reentrancy on the Target Smart Contract:
Reentrancy is a relatively easy vulnerability to fix, yet also a very easy mistake to make. It's easy to make a mistake because the vulnerable logic makes sense in real world logic. The vulnerable code should function correctly, if it were not interacting with a malicious contract. However, we do not expect an attacker's contract to be the receiver of the withdraw, thus throwing a wrench in real world logic. This is why we need to re-code this to function correctly using a secure pattern when dealing with DApps and web3.0.
Now let's correct the coding pattern by switching the order of operations to first decrease the accounts balance and then complete then initiate the withdraw transaction. The following image shows both the vulnerable and fixed code, where the original code is the on top and the fixed code is below:
Action Steps:
üImplement these changes in your contract.
üRedeploy both contracts making sure to update the address of the target contract in the attacker's contract
üTry this attack again, following the steps from above and observe how the results vary
With this simple change, our contracts balance is not decreased with each call to the withdraw function only the attackers balance is reduced until the attacker runs out of funds. If the attacker were to keep calling this function, the require check at the beginning of the function would fail as soon as the attacker ran out of funds. However, due to the usage of Call.Value and the lack of error handling, the funds may be incorrectly handled in the contract and error checking must be manually implemented. This is what we will look at next in regards to low level vs high level transfer functions.
Another relevant topic is that of the ways to transfer funds within Solidity. The "call" which was used in the withdraw function is a low-level function which can lead to issues and is largely replaced by the usage of Send or Transfer. Let's break these out and explain them:
Call.value()()
üReturns false on failure
üForwards available gas
üLow level function
Call.Value is dangerous because it forwards all of the available gas allowing for a reentrancy attack. It also does not return an error message and requires you to parse out the return Boolean value and perform an action based on this check. For example, if you were to make changes in the effects prior to the call.value, you may need to manually revert these changes as part of your error checking actions.
Send()
üReturns false on failure
üForwards a gas value of 2300
üLow level function
The send function limits the gas value to 2300 which helps prevent a reentrancy as there is a limit to how much the function can actually do before it fails. However, this is also a low-level function and you must be mindful of the lack of errors when this does fail exactly like the Call.value.
Transfer()
üActually, throws an error on failure
üForwards a gas value of 2300
üHigh level function
The transfer function provides a gas limit like the Send function but additionally provides an error and will revert changes made to the user's balance.
All of these functions are available for sending value out of the contract, however, only use low level functions with caution, and make sure to do error checking and make decisions on those errors. This will prevent hidden bugs in your code from error conditions. Also make sure to properly follow the checks, effects, interactions pattern in your code.
The DAO attack was the most famous blockchain attack ever performed. The DAO was a venture capital fund which pooled investors Ether for funding projects much like a crowdfunding application. The project initially raised 12.7 million Ether which at the time was equal to about 150 million dollars.
This Smart Contract contained a SplitDao function meant for removing funds into a child DAO when a user didn't like a majority decision of how to use funds. However, a Reentrancy vulnerability within the split function was found that ultimately allowed the attacker to remove 3.6 million Ether from the contract. This was a lot of money, but the bigger issue was the decision made by the Ethereum community to roll back the transaction, and give the users their funds back. As this violates the immutability of the blockchain. This should never happen again, but due to the immaturity of the network at the time, they felt it was needed.
This is the only time the Ethereum network violated the immutability of the blockchain and rolled back transactions on the Ethereum blockchain. The decision created a major idealistic split in the Ethereum community resulting in a hard fork of the network. Because of this split we now Ethereum classic and Ethereum. The network hard forked into two separate chains. One that contains the loss of funds on Ethereum Classic and one chain that does not contain the rollback, which is what we know as Ethereum.
Below we can see a snipped version of the original SplitDAO function which contained the issue:
If you take a look at lines 7-11 you will see a violation of our Checks à Effects à Interactions pattern.
On line 7-8 the contract is making withdrawal calls. However, following these withdrawals, the balances are updated on lines 10-11. If the attacker were to call back into the splitDao function when the interaction happened on line 8 then the attacker is able to drain the contract of millions of dollars. The balances are never updated until the attackers code is finished with its functionality.
In this chapter we took a look at secure coding patterns and high vs low level functions. We then interacted with vulnerable smart contracts that violated these secure coding principals. We exploited and fixed these issues ourselves in order to show how simple mistakes lead to huge losses in the case of attacks such as the famous DAO attack.
