Infoblox IP Reservierung via WebAPI in Powershell auslesen

Mit folgendem Powershell Skript, kann man über Servername, Domäne und VLAN ID eine Adressreservierung auf der Infoblox auslesen.

Die Abwicklung erfolgt über die WebAPI der Infoblox. Die Zugangsdaten stehen der Einfachheit halber im Skript, können aber natürlich auch via Übergabe oder Eingabe abgefragt werden.

Die VLAN ID wird via Extensible Attributes abgefragt, welche natürlich gepflegt sein sollten.
Als Rückgabe erscheint ein Objekt, mit IP-Adresse, Netzwerk, Maske, Gateway, VLAN ID und Typ der gefundenen Reservierung / IP Info

 

-> .get-infoblox-data.ps1 -ServerName "xyz" -DNSDomain "domain.local" -vlanID "10"

 

[CMDletBinding()]
param (
[Parameter(Mandatory = $true, Position = 0)]
[string]$ServerName,
[Parameter(Mandatory = $true, Position = 1)]
[string]$DNSDomain,
[Parameter(Mandatory = $true, Position = 2)]
[string]$vlanid
)

$global:ibAPIversion = "v2.7"
$global:ibFQDN = "infoblox_url"
$global:uriStart = "https://$global:ibFQDN/wapi/$global:ibAPIversion"
$pwd = ''
$username = ""
$secPW = $pwd | ConvertTo-SecureString  -asPlainText -Force
$global:cred = New-Object System.Management.Automation.PSCredential -ArgumentList $username, $secPW
$global:ityp=""

function get-fixed-addr ($vlanid, $ServerName, $DNSDomain) {
write-host "$ServerName.$DNSDomain"
try{
$fixedaddrs = Invoke-RestMethod -uri "$uriStart/fixedaddress?*SA_VLAN=$vlanid&_return_fields=options,name,comment,ipv4addr,extattrs&_max_results=1500"  -Credential $cred
$t = $fixedaddrs | ?{($_.name -like "*$ServerName.$DNSDomain*")}
$global:ityp="Reservation"
return $t.ipv4addr
}catch{
catchIBReturnError
return
}
}
function convert-prefix($prefix){
switch ($prefix) {
0{ "0.0.0.0" }
1{ "128.0.0.0" }
2{ "192.0.0.0" }
3{ "224.0.0.0" }
4{ "240.0.0.0" }
5{ "248.0.0.0" }
6{ "252.0.0.0" }
7{ "254.0.0.0" }
8{ "255.0.0.0" }
9{ "255.128.0.0" }
10{ "255.192.0.0" }
11{ "255.224.0.0" }
12{ "255.240.0.0" }
13{ "255.248.0.0" }
14{ "255.252.0.0" }
15{ "255.254.0.0" }
16{ "255.255.0.0" }
17{ "255.255.128.0" }
18{ "255.255.192.0" }
19{ "255.255.224.0" }
20{ "255.255.240.0" }
21{ "255.255.248.0" }
22{ "255.255.252.0" }
23{ "255.255.254.0" }
24{ "255.255.255.0" }
25{ "255.255.255.128" }
26{ "255.255.255.192" }
27{ "255.255.255.224" }
28{ "255.255.255.240" }
29{ "255.255.255.248" }
30{ "255.255.255.252" }
31{ "255.255.255.254" }
32{ "255.255.255.255" }
}
}
function catchIBReturnError{
$response = $_.Exception.Response
if ($response.StatusCode -eq [System.Net.HttpStatusCode]::BadRequest) {
$stream = $response.GetResponseStream()
$reader = New-Object System.IO.StreamReader($stream)
$reader.BaseStream.Position = 0
$reader.DiscardBufferedData()
$responseBody = $reader.ReadToEnd();
Write-Verbose $responseBody
$wapiErr = ConvertFrom-Json $responseBody
throw [Exception] "$($wapiErr.Error)"
$wapiErr
} else {
throw
}
}
function get-ip-from-arecord($ServerName,$DNSDomain){
#gibt es schon einen a-record?
try{
$infobloxHost = Invoke-RestMethod -uri "$global:uriStart/record:host?name~=$ServerName.$DNSDomain" -Credential $global:cred
$global:ityp="Host-Record"
#wechel ip?
$ip = $infobloxHost[0].ipv4addrs.ipv4addr
}catch{
catchIBReturnError
return
}
#gibt es schon einen host-record, wenn keinen a-record?
try{
if(!($infobloxHost)){
$infobloxHost = Invoke-RestMethod -uri "$global:uriStart/record:a?name~=$ServerName.$DNSDomain" -Credential $global:cred
$global:ityp="A-Record"
$ip = $infobloxHost[0].ipv4addr
}
}catch{
catchIBReturnError
return
}
return $ip
}
function get-network-from-ip($ip){
#erweiterte infos zur ip
try{
$infobloxIPv4Address = Invoke-RestMethod -uri "$global:uriStart/ipv4address?ip_address=$ip" -Credential $global:cred
#netzwerk
$ipNetwork = $infobloxIPv4Address[0].network
}catch{
catchIBReturnError
return
}
return $ipNetwork
}
function get-gateway-from-network ($ipNetwork) {
#gateway
try{
$infobloxGateway = Invoke-RestMethod -uri "$global:uriStart/network?ipv4addr=$ipNetwork&_return_fields=options,extattrs" -Credential $global:cred
$routers = $infobloxGateway[0].options | ?{$_.name -eq "routers"}
$routers = $routers.value
$vlan = $infobloxGateway[0].extattrs.SA_VLAN.value
}catch{
catchIBReturnError
return
}
return $routers, $vlan
}

#ip bekommen, sollte Reservierung, Host, a-record vorhanden sein
$returnIP = get-fixed-addr $vlanid $ServerName $DNSDomain
if(!($returnIP)){
write-host 'Reservierung nicht gefunden, suche nach Host- oder A-Record'
$returnIP = get-ip-from-arecord $ServerName $DNSDomain
}

#wenn ip vorhanden, netzwerk holen
if($returnIP){
$returnNW = get-network-from-ip $returnIP
$returnNoIP = "FALSE"
}else{$returnNoIP = "TRUE";$global:ityp=""}

#wenn netzwerk geholt, gateway finden
if($returnNW){
$returnGW = get-gateway-from-network $returnNW
$returnVLAN = $returnGW[1]
$returnGW = $returnGW[0]
$returnNWtmp = ($returnNW.split("/"))
$returnNW = ($returnNW.split("/"))["0"]
$returnSNM = convert-prefix $returnNWtmp["1"]
}

#werte zurückgeben
$ipObject = "" | Select IP,NW,SNM,GW,VLAN,Typ,NOIP
$ipObject.IP = $returnIP
$ipObject.NW = $returnNW
$ipObject.SNM = $returnSNM
$ipObject.GW = $returnGW
$ipObject.VLAN = $returnVLAN
$ipObject.Typ = $global:ityp
$ipObject.NOIP = $returnNoIP
write-host $ipObject
return $ipObject
Advertisements

Infoblox IP Reservierung via WebAPI in Powershell

Mit folgendem Powershell Skript, kann man über Servername, Domäne und VLAN ID eine Adressreservierung auf der Infoblox vornehmen.

Die Abwicklung erfolgt über die WebAPI der Infoblox. Die Zugangsdaten stehen der Einfachheit halber im Skript, können aber natürlich auch via Übergabe oder Eingabe abgefragt werden.

Die VLAN ID wird via Extensible Attributes abgefragt, welche natürlich gepflegt sein sollten.

 

-> .set-infoblox-data.ps1 -ServerName "xyz" -DNSDomain "domain.local" -vlanID "10"

 

[CMDletBinding()]
param (
    [Parameter(Mandatory = $true, Position = 0)]
    [string]$ServerName,
    [Parameter(Mandatory = $true, Position = 1)]
    [string]$DNSDomain,
    [Parameter(Mandatory = $true, Position = 2)]
    [string]$vlandID
)

$ibAPIversion = "v2.7"
$ibFQDN = "infoblox_url"
$uriStart = "https://$ibFQDN/wapi/$ibAPIversion"
$pwd = ''
$username = ""
$secPW = $pwd | ConvertTo-SecureString  -asPlainText -Force
$cred = New-Object System.Management.Automation.PSCredential -ArgumentList $username, $secPW

function catchIBReturnError{
    $response = $_.Exception.Response
    if ($response.StatusCode -eq [System.Net.HttpStatusCode]::BadRequest) {
        $stream = $response.GetResponseStream()
        $reader = New-Object System.IO.StreamReader($stream)
        $reader.BaseStream.Position = 0
        $reader.DiscardBufferedData()
        $responseBody = $reader.ReadToEnd();
        Write-Verbose $responseBody
        $wapiErr = ConvertFrom-Json $responseBody
        throw [Exception] "$($wapiErr.Error)"
    } else {
        throw
    }
}

try{
    $network = Invoke-RestMethod -uri "$uriStart/network?*SA_VLAN=$vlandID&_return_fields=options,extattrs" -Credential $cred
  }catch{
      catchIBReturnError
  }
if(!($network)){
    throw "Kein passendes Netzwerk mit der VLAN ID $vlandID gefunden. Extattrs gepflegt?"
}
#json string für reservierung
###############################
$Body = @{  name="$ServerName.$DNSDomain";
            ipv4addrs= @(
                @{
                    ipv4addr="func:nextavailableip:$($network._ref)"
                }
            )
            view = "WIE AUCH IMMER EURE ANSICHT HEIßT";
        }

$JSON = $Body | ConvertTo-json
####################################

#rückgabe abfangen wenn error
try{
    $reservierung = Invoke-RestMethod -uri "$uriStart/record:host?_return_fields=ipv4addrs" -Method Post -Credential $cred -Body $JSON -ContentType "application/json" -Verbose
}catch{
    catchIBReturnError
}
return "Reservierung wurde erfolgreich angelegt"

Outlook Kalender in PST exportieren via Powershell

kurz notiert:

Ein Export des Outlook Kalenders kann via Powershell Skript wie folgt realisiert werden

$Outlook = New-Object -ComObject Outlook.Application
$NS = $Outlook.GetNamespace('MAPI')
$Store = $NS.Stores | ? {$_.displayname -eq "abc@xyz.de"}
$Calendar = $Store.GetDefaultFolder([Microsoft.Office.Interop.Outlook.OlDefaultFolders]::olFolderCalendar)
#PST Store
$Outlook.Session.AddStore("c:tmptemp.pst")
$PST = $ns.Stores | ? {$_.filepath -eq "c:tmptemp.pst"}
$PSTRoot= $PST.GetRootFolder()
$PSTFolder= $NS.Folders.Item($PSTRoot.Name)
#Export
$Calendar.CopyTo($PST)
#Trennen des Archivs
$NS.GetType().InvokeMember('RemoveStore',[System.Reflection.BindingFlags]::InvokeMethod,$null,$NS,($PSTFolder))

Das Archiv könnte man anschließend auch in ein bestehendes Exchange (Online) Postfach importieren.

#mit exchange (online) verbinden
$Session = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://outlook.office365.com/powershell-liveid/ -Credential (Get-Credential) -Authentication Basic -AllowRedirection
New-MailboxImportRequest -Mailbox <Name> -FilePath <UNC-Pfad und Name der PST-Datei> -TargetRootFolder <Ordner im Postfach>
#Zwischenstand abfragen
Get-MailboxImportRequest <Name des Importvorgangs> | fl
#Import löschen
Remove-MailboxImportRequest

Lokale Administratoren aller Domänen Computer auflisten – Powershell

Möchte man eine Übersicht aller lokalen Administratoren-Konten / -Gruppen der Computer innerhalb einer Domäne erhalten, kann man das via Powershell Skript automatisiert laufen lassen. Das Ergebnis ist entweder in der Konsole sichtbar oder kann via Out-file in eine Datei geschrieben werden. Für das Skript wird das Active Directory Modul benötigt.

[fusion_builder_container hundred_percent=”yes” overflow=”visible”][fusion_builder_row][fusion_builder_column type=”1_1″ background_position=”left top” background_color=”” border_size=”” border_color=”” border_style=”solid” spacing=”yes” background_image=”” background_repeat=”no-repeat” padding=”” margin_top=”0px” margin_bottom=”0px” class=”” id=”” animation_type=”” animation_speed=”0.3″ animation_direction=”left” hide_on_mobile=”no” center_content=”no” min_height=”none”]

function get-adminmember-ofall{
$searchOU='ou=06computergruppen,dc=example,dc=local'
$anz_comp = Get-ADComputer -filter * -SearchBase $searchOU
$anz_comp = $anz_comp.count
$i=1
Get-ADComputer -filter * -SearchBase $searchOU|
     Foreach-Object{
			write-host "$i von $anz_comp"
			$server=$_.Name
			if(Test-Connection $_.Name -q){
				$i++
                Write-Host "Ueberpruefe $server" -fore green
                ([ADSI]"WinNT://$server/Administratoren").psbase.invoke('Members') |
                ForEach-Object{
                     $member=$_.GetType().InvokeMember('Name', 'GetProperty', $null, $_, $null)
                     New-Object PSObject -Property @{Server=$server;Account=$member}
                }
			}else{
				$i++
                Write-Host "$server - keine Verbindung" -fore red
           }
     }
}

lokale admins[/fusion_builder_column][/fusion_builder_row][/fusion_builder_container]

Verwaiste SIDs von Verzeichnissen und Dateien entfernen – Powershell

Wenn man Berechtigungen auf Ordner setzt und die Gruppe bzw. der Benutzer im Active Directory gelöscht wurde, bleiben die SIDs auf den Verzeichnissen und Dateien bestehen. Sie können dann allerdings nicht mehr aufgelöst werden. Somit steht dort anstelle des Usernamens nur die alte SID.
Diese kann man via Skript automatisiert finden und entfernen lassen.
Über
Import-Module .Dateiname_des_Skripts.ps1
kann das Skript geladen werden und anschließen unter Angabe des Pfades ausgeführt werden.
Remove-orphanedSID -path "C:..."
Über ein Aktivieren des Attributs “-whatif” kann erst einmal ein Testlauf erfolgen, der die SIDs noch nicht entfernt.

Function Remove-orphanedSID
{
[CmdletBinding()]
	Param
	(
		#Define parameters
		[Parameter(Mandatory=$true,Position=1)]
		[String]$path
	)
write-host "Sammle alle Ordner/Dateien"
$Apath = gci $path -recurse
write-host "Pruefe, das kann einige zeit in Anspruch nehmen"
foreach ($file in $Apath)
{
	$PSPath = $file.fullname
	try
		{
			$acl = Get-Acl -Path $PSPath
			foreach($acc in $acl.access )
			{
				$value = $acc.IdentityReference.Value
				if($value -match "S-1-5-*")
				{
					$acl.RemoveAccessRule($acc) | out-null
					Write-Host "Entferne SID: $value  von  $PSPath "
					Set-Acl -Path $PSPath -AclObject $acl #-whatif
				}
			}
		}
		catch
		{
			write-host $error
		}
}
}

Active Directory Object Restore via Powershell

Neben der Wiederherstellung von versehentlich gelöschten Objekten im AD durch ldp.exe, kann sie auch via Powershell erfolgen.

Notwendig ist dafür das ActiveDirectory Modul, welches in den RSAT Paketen enthalten ist und über die Windows Funktionen aktiviert werden kann.

Durch

Get-ADObject -SearchBase "CN=Deleted Objects,DC=example,DC=local" -filter * -IncludeDeletedObjects -Properties lastKnownParent

lassen sich alle gelöschten Objekte anzeigen. Das Property lastKnownParent gibt dabei zusätzlich die letzte bekannte OU aus, in der sich die jeweiligen Objekte befanden. Diese muss vor der Wiederherstellung des Objektes vorhanden sein und ggf. ebenfalls wiederhergestellt werden.

Über die Anpassung des Filters kann man sich nur das gewünschte Objekt anzeigen lassen:

Get-ADObject -Filter 'sAMAccountName -eq "username"' -SearchBase "CN=Deleted Objects,DC=eutech,DC=local"  -IncludeDeletedObjects -Properties *

Dadurch wird nach einem einzelnen Benutzer gesucht und alle Eigenschaften angezeigt.

Mit dem Pipen in das “Restore-ADObject” CMDlet kann das Objekt wiederhergestellt werden:

Get-ADObject -Filter 'sAMAccountName -eq "username"' -SearchBase "CN=Deleted Objects,DC=example,DC=local"  -IncludeDeletedObjects -Properties * | Restore-AdObject

Sollte eine OU wiederhergestellt werden, so muss man bedenken, dass der Wiederherstellungsbefehl nur die OU, nicht aber die darin enthaltenen Objekte wiederherstellt. Dies muss manuell oder z.B. durch eine foreach-Schleife erfolgen:

Get-ADObject -Filter * -IncludeDeletedObjects -Properties lastknownparent | ?{$_.lastknownparent -eq "OU=XY
ADEL:a7417fbf-3627-48f6-b48d-224cd642fcb1,CN=Deleted Objects,DC=example,DC=local"} | restore-adobject

-> Raussuchen aller gelöschten Objekte, filtern nach lastknownparent, wiederherstellen

Über den zusätzlichen Parameter “whatif” kann man den Wiederherstellungsprozess erst einmal testen.

ad-restore-ps

Subversion Needs Lock Property global setzen

Wenn man SVN zur Revisionsverwaltung von Quellcode nutzt, kann man über das Property “Needs Lock” festlegen, dass keine Änderung an Dateien vorgenommen werden kann, solange man diese Dateien nicht für sich gesperrt hat.
Sollte im Nachhinein auffallen, dass das Property nicht durchgängig gesetzt ist, kann das über folgende Skripte automatisiert werden.
Zunächst muss eine Liste aller Repositories erstellt werden, in deinen das Property fehlt.
Dazu kann folgendes Bash Skript auf dem Subversion Server genutzt werden.

#!/bin/bash
#Dateien in jedem Repository finden, die die Eigenschaft "Needs-Lock" nicht gesetzt haben
#
#findReposWithoutLogInHEAD.sh ausführen.
#Repositories ohne Needs-Lock Property werden ausgegeben.
#Ausgaben in Datei umleiten: ./findReposWithoutLogInHEAD.sh >> needLockFehlt.log
#Log auf PC kopieren und PS Script starten: checkoutWholeRepo.ps1

IFS=$'n'
cd /srv/svn-parent/
pwd

#Verzeichnis auflisten
array=(*/)

#Repos durchgehen
for dir in "${array[@]%/*}";
do #echo "$dir";
	files=`svn list -r HEAD -R http://subversion-server/svn/$dir --username *** --password "***" | grep -e ".*.vi$" -e ".*.ctl$" -e ".*.lvlib$" -e ".*.lvclass$" -e ".*.rtm$" -e ".*.lvproj$"`
	for fn in $files;
	do
		#wenn svn propget nicht gleich yes, dann ist prop nicht gesetzt
		if [[ $(svn propget svn:needs-lock http://subversion-server/svn/$dir/$fn --revprop -r HEAD) != "*"  ]]; then
			#echo Hier ist Prop nicht gesetzt
			echo http://subversion-server/svn/$dir/$fn
		fi
	done
done

Die Ausgabe des Skripts sollte in eine Datei umgeleitet werden, die dem Powershell Skript mitgegeben wird. Das Skript setzt das Vorhandensein des SVN Clients Tortoise SVN voraus!

#Liest Liste von Dateien ein, denen Needs:Lock fehlt, checkt das jeweilige Repository aus und setzt die Eigenschaft auf die Dateien
#

$files = cat "PfadzumLog.log"
#Array für die Repositories, wo die Namen drin stehen
$repoArray=@()
$lwDPfad
$pfadAufD ="D:SVNREPOS"

$checkout='checkout'
$usernamePasswort='--username "***" --password "***"'

#Initiierung für den ersten String
$a = $files[0].split("/")
$compString=$a[4] + "/" + $a[5]
Write-Host "Erstes Repo: $compString"
$repoArray+=("http://subversion-server/svn/"+$compString)

for ($i=0; $i -lt $files.length; $i++){
	if($files[$i] -match $compString){
        #Repo gleich, nichts zu tun
	}else{
		Write-Host "Neues Repo gefunden: "$files[$i]
		$a = $files[$i].split("/")
		$compString=$a[4] + "/" + $a[5]
		#Write-host $compString
        $repoArray+=("http://subversion-server/svn/"+$compString)
	}
}

#Jedes Repo einzeln auschecken
foreach($s in $repoArray){
Write-Warning "Checke $s aus"
#hier auschecken
svn.exe checkout $s $pfadAufD

    foreach($file in $files){
        if($file -match $s){
        #das sind die Dateien, die angepasst werden müssen
        #Pfad lokal anpassen
            #write-host $file
            $z = $file.split("/")
            $compString=$z[0] + "/" + $z[1] + "/" +$z[2] + "/" +$z[3] + "/" +$z[4] + "/" +$z[5]
            $lwDPfad = $file -replace $compString, $pfadAufD
            $lwDPfad = $lwDPfad -replace "/",""
            #Das ist der Pfad zur Datei, die angepasst werden muss:
            if(test-path $lwDPfad){
                write-host "Datei gefunden: $lwDPfad" -ForegroundColor green
                svn lock $lwDPfad
                svn propset svn:needs-lock yes $lwDPfad

                }
            else{
                write-host "Datei nicht gefunden: $lwDPfad" -ForegroundColor red}
        }
    }
#Fertig mit Repo, also commit und dann löschen
svn commit $pfadAufD -m "Needs Lock wurde auf die Dateien gesetzt"
read-host
Write-Warning "Lösche Inhalte..."
rmdir "$pfadAufD*" -force -Recurse
}

Damit werden nun alle gefundenen Repositories ausgecheckt und das Property gesetzt. Danach wird es wieder eingecheckt.