Portable Executable is file format which is used in Windows OS for executable files like .exe, .dll, .cpl etc. It is based on COFF (Common Object File Format).

A PE file is a data structure that holds information necessary for OS loader to load that executable into memory and execute it.

This article serves as basic overview of PE structure, understanding of which is useful for reverse engineering and understanding not just malware binaries.

Note

Examples provided in this article will be taken from random executable file, opened using analytics tool named PE-bear.

Code examples are from winnt.h WinAPI file. You can download these files as part of Visual Studio.

Structure

DOS Header

Is represented by first 64 bytes of every PE file. Following parts are the most important:
e_magic - Every PE File starts with 2 byte magic number 0x5A4D. It is used to verify if it is valid executable. The value can be seen in reverse order in screenshot below, due to Windows using little endian encoding
e_lfanew - These 4 bytes contain the offset of PE header. When the program needs to be loaded by Windows loader, it looks for this value to skip the DOS Stub and go directly to NT headers.

DOS Stub

Usually contains message "This program cannot be run in DOS mode". It is used as fallback for older DOS systems that cannot process PE files.

NT Headers

Are accesssed from address in e_lfanew

Signature - Serves for checking validity of the structure, has value of Ox4550 (PE)
File Headers - Contains information about structure of the whole file, such as the machine type of the executable code, a time stamp, a pointer to symbol table and various flags. Value in machine type can help you determine whether the executable is 32(value 0x4c) or 64 bit (value 0x64)
Optional Headers - Unlike name suggests, this header is not actually optional. It contains additional important information to File Headers, another magic number that determines whether file is 32/64bit, information about running subsystem, Preffered base address and security flags. Another important part is import,export, resource tables etc. which contain used APIs, imported functions, string and other static resources.

Section Header

Is an array that contains memory locations for each section.

Sections

.text - Contains the executable code. This section includes all compiled instructions that the processor will execute. The section is typically marked as executable and read-only for security purposes.

.data - Contains initialized global data. This includes variables with initial values that the program requires during execution. The section is marked as readable and writable.

.rdata - Contains read-only data, including import and export tables. It stores constant data, string literals, and critical tables that support dynamic linking functionality.

.rsrc - Contains resources such as icons, images, and strings. This section organizes resources in a hierarchical structure that applications can access during runtime.

.reloc - Contains relocation table that is used by loader for recalculating addresses in case the executable is not loaded at base address.

.tls(Thread Local Storage)- is a special storage class that contains thread specific data.

This list of sections is not exhaustive, just explains the most common ones.

When analyzing PE file, malicious executables can have unusually small or large headers or sections. Unusually large header can be a sign of obfuscation and for example small or empty import table can be sign of dynamic loading of libraries which is common for malware.

The post Portable Executable (PE) Format first appeared on Hard Wired.

Nushell je zajímavou alternativou k asi nejrozšířenější variantě shellu Bash. Nepatří do top pětky, ten kromě Bashe okupují Tcsh/Csh, Ksh, Zsh a Fish.

Dle autorů je Nushell nový typ shellu a už v úvodu dokumentace se dozvíte hlavní rozdíl. Programy v tradičních shellech spolu komunikují pomocí textových řetězců. Program zapíše text na standardní výstup a druhý program tento text přečte a zpracuje ze standardního vstupu.

To mohlo stačit v dobách kdy byly tyto shelly vytvořeny, ale doba se posunula. Dnes je v mnoha aplikacích defacto standard JSON. Například Bash v základu práci s JSON formátem nepodporuje a je potřeba použít nějaký JSON processor. Například jq.

Nushell tuto filozofii neboří, naopak rozšiřuje a umožňuje posílat i jiné datové typy.

Integers            -65535
Floats (decimals)   9.9999, Infinity
Strings             "hole 18", 'hole 18', hole 18, hole18, r#'hole18'#
Booleans            true
Dates               2000-01-01
Durations           2min + 12sec
File-sizes          64mb
Ranges              0..4, 0..<5, 0.., ..4
Binary              0x[FE FF]
Lists               [0 1 'two' 3]
Records             {name:"Nushell", lang: "Rust"}
Tables              [{x:12, y:15}, {x:8, y:9}], [[x, y]; [12, 15], [8, 9]]
Closures            {|e| $e + 1 | into string }, { $in.name.0 | path exists }
Cell-paths          $.name.0
Blocks              if true { print "hello!" }, loop { print "press ctrl-c to exit" }
Null (Nothing)      null
Any                 let p: any = 5

Jednou z výhod tohoto přístupu je, že výstupem může být tabulka, kterou další programy mohou zpracovat. Pokud chcete v Bashi například seřadit a filtrovat výstup příkazu ls, tak to bude kombinace příkazů ls, sort, grep, cut a možná i dalších. Největší obtíž bude kontext. Výstupy mezi program budou jen textové řetězce bez kontextu. Ale zkušený Linux admin to určitě zvládne s přehledem.

V Nushelu další program ví, že je to tabulka, která má nějaké sloupce co se nějak jmenují a hodnoty ve sloupcích mají nějaký typ. Tím výsledná sekvence příkazů vypadá mnohem přirozeněji a intuitivněji.

Příklad 1: Proces co zabírá nejvíc paměti

~/bin> ps
╭───┬──────┬──────┬──────┬──────────┬──────┬──────────┬──────────╮
│ # │ pid  │ ppid │ name │  status  │ cpu  │   mem    │ virtual  │
├───┼──────┼──────┼──────┼──────────┼──────┼──────────┼──────────┤
│ 0 │    1 │    0 │ init │ Sleeping │ 0.00 │ 339.9 kB │ 997.3 GB │
│ 1 │ 1724 │    1 │ init │ Sleeping │ 0.00 │ 249.8 kB │ 997.3 GB │
│ 2 │ 1725 │ 1724 │ bash │ Sleeping │ 0.00 │   3.5 MB │ 222.2 GB │
│ 3 │ 1762 │ 1725 │ sudo │ Sleeping │ 0.00 │   2.5 MB │ 309.2 GB │
│ 4 │ 1763 │ 1762 │ nu   │ Running  │ 0.00 │  18.4 MB │ 150.1 GB │
╰───┴──────┴──────┴──────┴──────────┴──────┴──────────┴──────────╯

Výstupem je tabulka, co má sloupce. V našem případě nás zajímá sloupec mem. Ten má jako řádky hodnoty typu file-size podle kterých lze sortovat.

~/bin> ps | sort-by mem
╭───┬──────┬──────┬──────┬──────────┬──────┬──────────┬──────────╮
│ # │ pid  │ ppid │ name │  status  │ cpu  │   mem    │ virtual  │
├───┼──────┼──────┼──────┼──────────┼──────┼──────────┼──────────┤
│ 0 │ 1724 │    1 │ init │ Sleeping │ 0.00 │ 249.8 kB │ 997.3 GB │
│ 1 │    1 │    0 │ init │ Sleeping │ 0.00 │ 339.9 kB │ 997.3 GB │
│ 2 │ 1762 │ 1725 │ sudo │ Sleeping │ 0.00 │   2.5 MB │ 309.2 GB │
│ 3 │ 1725 │ 1724 │ bash │ Sleeping │ 0.00 │   3.5 MB │ 222.2 GB │
│ 4 │ 1763 │ 1762 │ nu   │ Running  │ 0.00 │  18.4 MB │ 150.1 GB │
╰───┴──────┴──────┴──────┴──────────┴──────┴──────────┴──────────╯

Sort řadí od nejmenšího, takže je ještě potřeba výstup obrátit.

~/bin> ps | sort-by mem | reverse
╭───┬──────┬──────┬──────┬──────────┬──────┬──────────┬──────────╮
│ # │ pid  │ ppid │ name │  status  │ cpu  │   mem    │ virtual  │
├───┼──────┼──────┼──────┼──────────┼──────┼──────────┼──────────┤
│ 0 │ 1763 │ 1762 │ nu   │ Running  │ 0.00 │  18.4 MB │ 150.1 GB │
│ 1 │ 1725 │ 1724 │ bash │ Sleeping │ 0.00 │   3.5 MB │ 222.2 GB │
│ 2 │ 1762 │ 1725 │ sudo │ Sleeping │ 0.00 │   2.5 MB │ 309.2 GB │
│ 3 │    1 │    0 │ init │ Sleeping │ 0.00 │ 339.9 kB │ 997.3 GB │
│ 4 │ 1724 │    1 │ init │ Sleeping │ 0.00 │ 249.8 kB │ 997.3 GB │
╰───┴──────┴──────┴──────┴──────────┴──────┴──────────┴──────────╯

Zajímají jen Running procesy, takže můžeme využít sloupce status.

~/bin> ps | sort-by mem | reverse | where status == Running
╭───┬──────┬──────┬──────┬─────────┬──────┬─────────┬──────────╮
│ # │ pid  │ ppid │ name │ status  │ cpu  │   mem   │ virtual  │
├───┼──────┼──────┼──────┼─────────┼──────┼─────────┼──────────┤
│ 0 │ 1763 │ 1762 │ nu   │ Running │ 0.00 │ 18.7 MB │ 150.1 GB │
╰───┴──────┴──────┴──────┴─────────┴──────┴─────────┴──────────╯

Můžeme si tabulku zjednodušit tím, že nás zajímají jen sloupce pid, name a mem.

~/bin> ps | sort-by mem | reverse | where status == Running | select pid name mem
╭───┬──────┬──────┬─────────╮
│ # │ pid  │ name │   mem   │
├───┼──────┼──────┼─────────┤
│ 0 │ 1763 │ nu   │ 18.7 MB │
╰───┴──────┴──────┴─────────╯

Nakonec si pomocí příkazu get vytáhneme jen PID procesu.

~/bin> ps | sort-by mem | reverse | where status == Running | select pid name mem | get pid
╭───┬──────╮
│ 0 │ 1763 │
╰───┴──────╯

A tohle je jen takové škrabkání po povrchu. Nu disponuje škálou příkazů na práci s tabulkami. Také na práci se záznamy což je JSON, seznamy a řetězci. Vše je pěkně popsáno v dokumentaci v sekci Nu Fundamentals.

Nushell jede na Windows, macOS a Linux operačních systémech. Metody instalace jsou popsány v dokumentaci. Pro Debian/Ubuntu systém stačí přidat zdroj.

curl -fsSL https://apt.fury.io/nushell/gpg.key | sudo gpg --dearmor -o /etc/apt/trusted.gpg.d/fury-nushell.gpg
echo "deb https://apt.fury.io/nushell/ /" | sudo tee /etc/apt/sources.list.d/fury.list
sudo apt update
sudo apt install nushell

Nushell není kompatibilní s Bashem a jinými tradičními shelly. Takže není kompletní náhrada za standardní systémový shell. Ale dokáži si představit Nu jako "every day" shell na takovou běžnou uživatelskou Linuxařinu. Ale ještě víc pokud z mého programu potřebuji zpracovat strukturovaný výstup nebo naopak do mého programu dostat strukturovaný vstup. To může být velice silný nástroj. Nushell tvrdí že dokáže pracovat s JSON, YAML, Excel a dokonce i s SQLite. To může některé aplikace velice zjednodušit. Seznam všech podporovaných formátů najdete v dokumentaci.

Happy coding!

The post Nushell first appeared on Hard Wired.

Článek navazuje na Gitea v Dockeru s daty na Synology a Gitea na veřejné subdoméně. Tentokrát si ukážeme, jak vytvořit nový soukromý repozitář a posílat do něj změny.

Předpoklady

• Máme funkční Giteu na vlastní subdoméně, do které se dokážeme přihlásit
• Byly provedeny všechny kroky z předchozích návodů
• Článek se zaměřuje na Windows ale na Linuxu to bude to samé nebo hodně podobné
• Na počítači máme funkční SSH a GIT.

Vytvoření soukromého repozitáře

Přihlásíme se do naší Gitey. Pluskem zvolíme nový repozitář. Zadáme název repozitáře, soukromy-repo-na-smazani. Vybereme Nastavit repozitář jako soukromý a potvrdíme. Vytvoří se prázdný repozitář.

Vytvoření SSH klíče

Pro komunikaci s repozitářem budeme používat SSH. Budeme muset vytvořit pár klíčů, soukromý a veřejný. Soukromý bude u nás na počítači a veřejný budeme nahrajeme k repozitáři, jako přístupový.

Ujistíme se že v c:\Users\<username> máme složku .ssh. Poté v terminálu zadáme příkaz na vygenerování klíče pro přístup do Gitea.

ssh-keygen -t rsa -b 4096 -C "<váš email>" -f ~/.ssh/gitea-example-com

To ve složce .ssh vytvoří dva soubory. gitea-example-com a gitea-example-com.pub. Ten druhý musíme nahrát k repozitáři.

Přidání klíče do Gitea repozitáře

Otevřeme si repozitář. Nastavení > Klíče pro nasazení > Přidat klič pro nasazení. Pojmenujeme si ho, například Domácí klíč. A obsah gitea-example-com.pub zkopírujeme do pole Obsah. Nesmíme zapomenout zaškrtnout volbu Povolit zápis a potvrdit.

Nastavení SSH na počítači

Pokud ve složce c:\Users\<username>\.ssh nemáte soubor config, vytvořte ho a přidejte následující.

Host gitea.example.com
  HostName gitea.example.com
  User git
  Port 222
  IdentityFile c:\Users\<username>\.ssh\gitea-example-com
  IdentitiesOnly yes

Pro hosta gitea.example.com se nastaví odpovídající host name, uživatel, port pro připojení a cesta k privátnímu klíči. Volba IdentitiesOnly zajistí, že pro konkrétního hosta se použijí parametry, které jsou nastaveny.

Připojení repozitáře

Buď můžete připojit už existující repozitář z vašeho počítače, nebo vytvoříte nový. Vytvoříme nový.

Vytvořte složku kde bude nový repozitář. Obecně se pojmenuje názvem repozitáře co jsme vytvořili na naší Gitea.

mkdir soukromy-repo-na-smazani

Přesuneme se do něj.

cd soukromy-repo-na-smazani

Inicializujeme prázdný repozitář.

git init

Vytvoříme první soubor README.md.

touch README.md

Vytvoříme hlavní větev main.

git checkout -b main

Přidáme soubor README.md do git repozitáře.

git add README.md

Vytvoříme první commit.

git commit -m "První commit"

Napojíme náš repozitář z Gitea.

git remote add origin git@gitea.example.com:<gitea username>/soukromy-repo-na-smazani.git

Odešleme změny do vzdáleného repozitáře.

git push -u origin main

Když se nyní podíváme do repozitáře na gitea.example.com, uvidíme náš první commit.

The post Gitea a první soukromý repozitář first appeared on Hard Wired.

Windows Architecture

Windows architecture follows layered design with two main components:

User Mode

This mode is made of system processes, services, application and environments running on the system. All of these components have limited access to hardware and rely on kernel mode for hardware interaction.
Interface between user mode and kernel functions is called environment subsystem.
Each of these implement different API sets.
Three main environment subsystems exist:
1.Win32
2.OS/2
3.POSIX

Security subsystem

Deals with security tokens, manages access to resources based on permissions, handles authentication. Manages Active Directory

Kernel Mode

Has full access to system hardware and resources and runs code in Protected Memory. Kernel mode handles memory management, device drivers, process management, thread prioritization etc.

System Call

When user mode program needs access to any restricted resource or hardware, it makes system call. This call is processed by kernel mode.

Hardware Abstraction Layer

Acts as a bridge between kernel mode and hardware. Translates generic kernel instructions to specific instructions for given hardware.

Memory Management

Windows has sophisticated memory management system for physical(RAM) and virtual(RAM and Disk) memory utilization.

Virtual Address Space - is set of virtual memory that process can use. This memory is private and cannot be accessed by other processes unless shared.
Virtual address does not represent physical location in memory. System maintains internal data structure Page Table for each process. Every time thread references virtual address, system translates it to physical one.
Virtual address space is divided into two partitions - system and process.

Memory Types

• User mode/Kernel mode:
  Memory allocations are segregated based on mode to ensure security
• x86/x64:
  Represent addressable memory space for different CPU architectures. Every 32-bit(x86) app has up to 4GB of virtual memory space, while 64-bit (x64) has up to 8TB.
• Paged Pool:
  Dynamically allocated memory that can be swapped between RAM and paging file on disk. This serves as memory usage optimization, or when RAM memory is full.
• Non-paged pool:
  Hold critical kernel mode data that must be always accessible in RAM as long as corresponding objects are allocated. This data is not paged to disk.

Page States

• Free: The page is available to be reserved, committed, or simultaneously reserved and committed
• Reserved: The page is reserved for future use, but it does not have any physical storage associated with it. Reserved memory cannot be used by other functions
• Committed: Memory have been allocated in RAM/paging file(s) on disk. Page is accessible and access is controlled by Memory Protection Constants

Memory Protection Constants

These constants specify permissions, which define operations that can be done on specified memory region. There is many of them, so I will list just a few that are probably most common, the rest can be found in Microsoft Documentation.

• PAGE_EXECUTE_READWRITE - Enables execute, read-only, or read/write access to the committed region of pages
• PAGE_READWRITE - Enables read-only or read/write access to the committed region of pages
• PAGE_READONLY - Enables read-only access to the committed region of pages
  ...

C++ Code Example

Let's apply previous information to allocate memory in a process.

LPVOID memBlock = VirtualAllocEx(hProcess, NULL, sizeof(payload), (MEM_RESERVE | MEM_COMMIT), PAGE_EXECUTE_READWRITE);

Here, we allocate variable 'memBlock' of 'LPVOID' type, assigning it result of 'VirtualAllocEx'(memoryapi.h) function. LPVOID represents address of any type.
Executing this function commits memory to which we can write data later.
Parameters:

1. hProcess is handle to process in which virtual address space the memory will be allocated
2. This parameter specifies starting address. NULL means function will determine where to allocate the region
3. Size of memory region to allocate in bytes
4. Set page state, multiple can be used with bitwise '|' operator
5. Requires memory protection constant

Data Execution Prevention (DEP)

Is a security technology, that makes some pages in memory non-executable. This prevents potential attackers from executing malicious code in these regions of memory using exploits like buffer overflow.

Address Space Layout Randomization (ASLR)

Is a security technique that randomizes base addresses of processes, DLL's and critical data structures like stack and heap. This prevents the attacker from hardcoding memory locations, which are like to be changed on each application restart. It also makes mistakes expensive, since writing to wrong address leads to application crash.
Effectiveness of this technique can be significantly diminished by reducing entropy.

WinAPI

WinAPI is a collection of functions, divided between many DLL's, that allow applications to interact with underlying Windows functionalities through code.
Many of these functions are documented in Win32 API MSDN.

Important Windows DLL's

• kernel32.dll - Exposes functions for memory management, file system access and console I/O, thread creation...
• user32.dll - Provides functions for managing windows, menus, controls and handling user input
• ntdll.dll - Many user mode API's rely on ntdll, as it exposes Native API
• ws2_32.dll - Implements Windows Websocket API, it is crutial for network programming
• advapi32.dll - Provides security features like authentication, access control and registry manipulation

The post Windows Architecture & WinAPI first appeared on Hard Wired.

Starship je cross-shell prompt napsaný v Rustu co vám obohatí váš shell. Jak to může vypadat se dozvíte hned na úvodní stránce projektu.

The minimal, blazing-fast, and infinitely customizable prompt for any shell!

Starship je multiplatformní a multi-shellový, ale tady se budeme zabývat instalací pro cmd na windows.

Samotnou instalaci můžete provést několika způsoby. Prvním způsobem je stažení klasického msička z githubu starshipu a normálně ho nainstalovat. Nebo můžete být víc cool a použít Winget. Winget je pokus Microsoftu o "balíčkovací systém" přes příkazovou řádku. Někdo by si mohl říct že to bude jako Debianí apt nebo Fedorácký yum. Ne. Jediné co to udělá, je to, že stáhne msi soubor a spustí ho.

winget install --id Starship.Starship

Po úspěšné instalaci je nutné stáhnout Clink. Jelikož cmd je trochu prehistorie, potřebuje obohatit ještě o trošku více. Clink přinese do cmd opravdové doplňování a historii.

Clink combines the native Windows shell cmd.exe with the powerful command line editing features of the GNU Readline library, which provides rich completion, history, and line-editing capabilities. Readline is best known for its use in the Unix shell Bash, the standard shell for Mac OS X and many Linux distributions.

Ze stránek projektu stáhněte a nainstalujte poslední verzi Clinku.

Jak tohle budete mít, tak je potřeba vytvořit soubor starship.lua, který umístíte do %LocalAppData%\clink\. Obsahem souboru bude následující:

load(io.popen('starship init cmd'):read("*a"))()

Teď když spustíte čerstvé cmd, tak uvidíte následující.

Nebo něco takového. (v prvním případě je to přes Microsoft Terminál, v druhém případě je to čisté cmd)

Tak to už vám běží Starship. Ale furt to nevypadá tak pěkně jako na stránkách Starshipu.

V první řadě je potřeba doinstalovat font a to Nerd Font.

Tady to bude trochu divočejší. Potřebujeme vybrat font, který bude umět zobrazení různých symbolů jako vidíme na obrázku výše.

Pokud používám Windows Terminal aplikaci, nainstaloval jsem a mám nastavený font Caskaydia Cove Nerd Font. Respektive CaskaydiaCove Nerd Font Mono.

Blbé je, že klasické cmd ho neumí použít. Pro tento případ jsem použil font 3270 Nerd Font a v cmd ho nastavil. (ttf soubory)

Potvrďte, změní se font konzole. Zároveň se už korektně zobrazí základní preset Starshipu a uvidíte zelenou tučnou špidlatou závorku evokující šipku doprava.

Tohle ale ještě furt není to co chceme. Teď ještě potřebujeme nějaký pěkný preset. Můžeme použít Bracketed Segments.

Instalaci provedeme přes cmd.

starship preset bracketed-segments > %userprofile%/.config/starship.toml

Spusťte nové cmd a když půjdete někam, kde může něco zajímavého říct, tak to zobrazí v nainstalovaném presetu. V mém případě jsem spustil cmd v Java Scriptovém projejktu.

Pro klasické cmd:

Pro cmd přes Windows Terminal:

Příkazová řádka mě informuje, že se nacházím ve větvi master a verze nodejs je 16. Co vám bude kontextově napovídáno je nakonfigurováno ve starship.toml, který jsme vytvářeli výše.

[aws]
format = '\[[$symbol($profile)(\($region\))(\[$duration\])]($style)\]'

[bun]
format = '\[[$symbol($version)]($style)\]'

[c]
format = '\[[$symbol($version(-$name))]($style)\]'

[cmake]
format = '\[[$symbol($version)]($style)\]'

[cmd_duration]
format = '\[[⏱ $duration]($style)\]'

[cobol]
format = '\[[$symbol($version)]($style)\]'

[conda]
format = '\[[$symbol$environment]($style)\]'

[crystal]
format = '\[[$symbol($version)]($style)\]'

[daml]
format = '\[[$symbol($version)]($style)\]'

[dart]
format = '\[[$symbol($version)]($style)\]'

[deno]
format = '\[[$symbol($version)]($style)\]'

[docker_context]
format = '\[[$symbol$context]($style)\]'

[dotnet]
format = '\[[$symbol($version)(? $tfm)]($style)\]'

[elixir]
format = '\[[$symbol($version \(OTP $otp_version\))]($style)\]'

[elm]
format = '\[[$symbol($version)]($style)\]'

[erlang]
format = '\[[$symbol($version)]($style)\]'

[gcloud]
format = '\[[$symbol$account(@$domain)(\($region\))]($style)\]'

[git_branch]
format = '\[[$symbol$branch]($style)\]'

[git_status]
format = '([\[$all_status$ahead_behind\]]($style))'

[golang]
format = '\[[$symbol($version)]($style)\]'

[haskell]
format = '\[[$symbol($version)]($style)\]'

[helm]
format = '\[[$symbol($version)]($style)\]'

[hg_branch]
format = '\[[$symbol$branch]($style)\]'

[java]
format = '\[[$symbol($version)]($style)\]'

[julia]
format = '\[[$symbol($version)]($style)\]'

[kotlin]
format = '\[[$symbol($version)]($style)\]'

[kubernetes]
format = '\[[$symbol$context( \($namespace\))]($style)\]'

[lua]
format = '\[[$symbol($version)]($style)\]'

[memory_usage]
format = '\[$symbol[$ram( | $swap)]($style)\]'

[nim]
format = '\[[$symbol($version)]($style)\]'

[nix_shell]
format = '\[[$symbol$state( \($name\))]($style)\]'

[nodejs]
format = '\[[$symbol($version)]($style)\]'

[ocaml]
format = '\[[$symbol($version)(\($switch_indicator$switch_name\))]($style)\]'

[openstack]
format = '\[[$symbol$cloud(\($project\))]($style)\]'

[package]
format = '\[[$symbol$version]($style)\]'

[pulumi]
format = '\[[$symbol$stack]($style)\]'

[purescript]
format = '\[[$symbol($version)]($style)\]'

[python]
format = '\[[${symbol}${pyenv_prefix}(${version})(\($virtualenv\))]($style)\]'

[raku]
format = '\[[$symbol($version-$vm_version)]($style)\]'

[red]
format = '\[[$symbol($version)]($style)\]'

[ruby]
format = '\[[$symbol($version)]($style)\]'

[rust]
format = '\[[$symbol($version)]($style)\]'

[scala]
format = '\[[$symbol($version)]($style)\]'

[spack]
format = '\[[$symbol$environment]($style)\]'

[sudo]
format = '\[[as $symbol]\]'

[swift]
format = '\[[$symbol($version)]($style)\]'

[terraform]
format = '\[[$symbol$workspace]($style)\]'

[time]
format = '\[[$time]($style)\]'

[username]
format = '\[[$user]($style)\]'

[vagrant]
format = '\[[$symbol($version)]($style)\]'

[vlang]
format = '\[[$symbol($version)]($style)\]'

[zig]
format = '\[[$symbol($version)]($style)\]'

Tak a teď vám funguje Starship na Windows.

Pokud používáte PowerShell nemusíte instalovat Clink. Fonty pořešíte úplně stejně. V PowerShellu si vypíšete, kde se má nacházet konfigurační soubor.

echo $PROFILE

Dostanete něco ve smyslu ...\Documents\WindowsPowerShell\Microsoft.PowerShell_profile.ps1. Pokud soubor neexistuje, tak ho vytvořte a do něj přidejte a uložte:

Invoke-Expression (&starship init powershell)

Spusťte nový PowerShell. Možná na vás vyskočí chyba running scripts is disabled on this system. To bude asi nějaká bezpečnost nebo co. Abychom se toho zbavili, musíme pustit PowerShell jako správce a spustit následující příkaz:

Set-ExecutionPolicy Unrestricted

Jak moc je to "velká bezpečnost díra" si musí každý zhodnotit sám.

Restartujeme PowerShell. Pokud už máme nastavené odpovídající písmo a jsme například v nodejs projektu, uvidíme opět kontextové informace.

The post Starship pro Widláky first appeared on Hard Wired.