Hope This Helps

Ich hab hier ein paar nützliche Befehle die ein Message Tracing der Nachrichten ermöglicht die in Exchange Online gesendet oder empfangen werden. Als erstes muss die Verbindung zu Exchange Online stehen.
Zeige mir alle Mails die in den letzten 24 Stunden den Status FAILED hatten

Get-MessageTrace -StartDate (Get-Date).addhours(-24) -EndDate (Get-Date).addhours(-0) | Where-Object {($_.Status -eq 'Failed')}

Zähle Mails mit einem bestimmten Betreff der letzten 24 Stunden

(Get-MessageTrace -StartDate (Get-Date).addhours(-24) -EndDate (Get-Date).addhours(-0) | Where-Object {($_.Subject -like "Discount*")}).count

Zeige mir alle E-Mails mit einem bestimmten Empfänger der letzten 24 Stunden mit dem Status FAILED und exportiere diese in eine CSV

Get-MessageTrace -StartDate (get-date).adddays(-1) -EndDate (get-date).addhours(-0) -Status 'Failed' -RecipientAddress 'EMAILADRESSE' | Export-CSV -Path 'PFAD_ZUR_CSV\EMAILADRESSE.csv' -Encoding UTF8

Zeige mir alle E-Mails eines Absenders der letzten 25 Tage

Get-MessageTrace -StartDate (get-date).adddays(-25) -EndDate (get-date).addhours(-0) -SenderAddress 'ABSENDERADRESSE'

Als erstes muss die Verbindung zu Exchange Online stehen. Für meine Funktionen hatte ich eine CSV als Grundlage.
Die Struktur der CSV sah wie folgt aus :

Verteiler;Mitglieder
Verteiler-NAME;"USER1;USER2;USER3;USER4"

Aus Grunden der Sicherheit ist hier WhatIf auf True gesetzt ! d.h. es werden keine Verteiler oder Mitglieder hinzugefügt.
Wenn ihr sicher seit das alles richtig ist könnt ihr einfach bei WhatIf $true auf $false ändern.

#region Vars
    $DLCSV = Import-Csv -Path "$env:HOMEDRIVE\DEIN_PFAD_ZUR_CSV\Verteiler.csv" -Encoding UTF8 -Delimiter ';'
    # new object
    $CsvOutput = @()
#endregion Vars

#region CreateGroup_ReadCSV
foreach ($entry in $DLCSV) {
    $DL_NAME    = $entry.Verteiler
    $DL_MEMBERS = $entry.Mitglieder
    $DL_MEMBER = ($DL_MEMBERS -split ';')  
    
    #region CreateNewDL
    $NewDisGroupParameter = $null
    $NewDisGroupParameter = @{
        Name   = $DL_NAME
        WhatIf = $true
    }
    $crDis = (New-DistributionGroup @NewDisGroupParameter)
    #endregion CreateNewDL

    Start-Sleep -Seconds 1.5

    #region AddMembersToDL
    foreach ($m in $DL_MEMBER) {
        $user = $m.Trim()
        Add-DistributionGroupMember -Identity $DL_NAME -Member $user -whatif:$true
    }
    #endregion AddMembersToDL
}
#endregion CreateGroup_ReadCSV

Wenn man Exchange Online mit der Powershell administrieren will muss zuvor ein connect aufgebaut werden. Dieser wird mit diesem Schnipsel aufgebaut.

<# Connect To Exchange Online #>
if (-not ($ExoCreds)) {
   $ExoCreds = Get-Credential -Message 'Global Admin please' -UserName 'ADMINUSER'
}

$ProxyOptions = New-PSSessionOption -ProxyAccessType None

$ExoSession = $null
Get-PSSession -ErrorAction SilentlyContinue | Where-Object {$_.ComputerName -eq 'outlook.office365.com'} | Remove-PSSession -ErrorAction SilentlyContinue -Confirm:$false

$ExoSession = New-PSSession -ConfigurationName Microsoft.Exchange -ConnectionUri https://outlook.office365.com/powershell-liveid/ -Credential $ExoCreds -Authentication Basic -AllowRedirection -SessionOption $ProxyOptions
Import-PSSession $ExoSession -DisableNameChecking -AllowClobber

E-Mail senden über Office 365 mit der Powershell

[System.Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
 
 $PWD = 'YOURPASSWORD' | ConvertTo-SecureString -AsPlainText -Force 
 $USER = New-Object System.Management.Automation.PSCredential ("USERLOGIN", $PWD)

 $Para = @{
    SmtpServer = 'smtp.office365.com'
    UseSsl     = $true
    Port       = '587' 
    Credential = $USER
    Body       = 'TESTMAIL' 
    To         = 'EMPFÄNGERADRESSE'
    From       = 'SENDERADRESSE' 
    Subject    = 'Testmail'
} 
 
Send-MailMessage @Para

Vault ist ein Passwort Manager und mehr für den professionellen Einsatz. Die Sicherheitsfeatures sind beeindruckend und das alles in einem OpenSource Tool das keinen Cent kostet. Unter anderem bietet das Tool die Möglichkeit OneTimePasswords (otp) zu erstellen. Unter Linux sind die otp einfach zu nutzen unter Windows leider nicht ganz so einfach.

Um eine ähnlich komfortabele Lösung für Windows Benutzer zu bieten habe ich hier ein kleines Powershell Skript geschrieben.
Es wird putty vorausgesetzt anderenfalls umschreiben

Hier gehts zu Vault von Hashicorp : https://www.vaultproject.io/

Eine Anmeldung mit einem Token sieht dann so aus :

Eine Anmeldung mit user/pass ist auch möglich:

# vault-ssh.ps1 for windows tested on Powershell 5.1
# you need an puuty installation, NOT ONLY THE EXE FILE !
# read parameter
param (
    [string]$VR,
    [string]$VU,
    [string]$VI,
    [string]$VUU,
    [string]$LM="t",
    [int]$d=0
)
# function
function show_help {
  Write-Host ""
  Write-Host "-VR Vault Role"
  Write-Host "-VU User for target host"
  Write-Host "-VI IP address for target host"
  Write-Host "-LM define the login method ( use u / t for userpass / token default ist token)"
  Write-Host "      if you use userpass -VUU is required"
  Write-Host "        -VUU vault username"
  Write-Host "-d 1 activate debug mode (default is -d 0)"
  Write-Host ""
  Write-Host "examples :"
  Write-Host "---------------------------------------------------------------"
  Write-Host "                            TOKEN"
  Write-Host "---------------------------------------------------------------"
  write-Host "vault-ssh.ps1 -VR admin -VU root -VI 192.168.2.1"
  Write-Host "---------------------------------------------------------------"
  Write-Host "                            USERPASS"
  Write-Host "---------------------------------------------------------------"
  write-Host "vault-ssh.ps1 -VR admin -VU root -VI 192.168.2.1 -LM u -VUU YOUR_USERNAME"
  Write-Host " "
  
  exit 0
}
# check parameter
if ([string]::IsNullOrWhitespace($VR) -or [string]::IsNullOrWhitespace($VU) -or [string]::IsNullOrWhitespace($VI)) {
  Write-Host -ForegroundColor Yellow "not enough parameter !"
  show_help
}
# get vault address
try {
    $VAULT_SRV=$env:VAULT_ADDR
} catch {
    Write-Host -ForegroundColor Red "Environment Variable VAULT_ADDR not found please set the Enviroment with 'setx VAULT_ADDR ADDRESS_TO_VAULT_HA'"
    exit 99
}
# get vault master #
try {
  # /sys/leader
  $VAULT_LEADER=Invoke-RestMethod -Method Get -Uri "$VAULT_SRV/v1/sys/leader" | ConvertTo-Json | ConvertFrom-Json
  [string]$VAULT_LEADER_ADDR=$VAULT_LEADER.leader_address
  # debug output
  if ( $d -eq 1 ) { Write-Host -ForegroundColor Yellow "Leader : $VAULT_LEADER_ADDR " }
  if ( $VAULT_LEADER_ADDR -ne $VAULT_SRV ) {
    # debug output
    if ( $d -eq 1 ) { Write-Host -ForegroundColor Red "$VAULT_SRV is not the leader connect to $VAULT_LEADER_ADDR instead" $msg }
    $VAULT_SRV=$VAULT_LEADER_ADDR
  } else {
    # debug output
    if ( $d -eq 1 ) { Write-Host -ForegroundColor Yellow "VAULT_ADDR is the leader address" }
  }
} catch {
  Write-Host -ForegroundColor Red "could not get vault master !"
  Exit 99
} 
# check vault health 
try {
    $VAULT_REQ=Invoke-WebRequest -Uri "$VAULT_SRV/v1/sys/health" -Method GET -UseBasicParsing
    $VAULT_STATUS=$VAULT_REQ.StatusCode
    switch ($VAULT_STATUS) {
        # check status code 
        200 { 
              $msg="VAULT is initialized, unsealed, and active"
              $vok="Green"
            }
        429 { 
              $msg="VAULT is unsealed and standby"
              $vok="Yellow"
            }
        472 { 
              $msg="VAULT is in data recovery mode replication secondary and active"
              $vok="Yellow"
            }
        473 { 
              $msg="VAULT is in performance standby"
              $vok="Yellow"
            }
        501 { $msg="VAULT is not initialized"
              $vok="Red"
            }
        503 { 
              $msg="VAULT ist sealed"
              $vok="Red"
            }
    }
} catch {
    Write-Host -ForegroundColor Red "Could not check vault status ! is the address correct ? $VAULT_SRV"
    Exit 97
}
# debug output 
if ( $d -eq 1 ) { Write-Host -ForegroundColor $vok $msg }
switch ($LM) {
  "t" {
      # get vault-token 
      try {
        $VAULT_TOKEN=$env:VAULT_TOKEN
        if ([string]::IsNullOrWhitespace($VAULT_TOKEN)) {
          # if no enviroment set ask for token
          $VAULT_TOKEN=Read-Host -AsSecureString "Need your vault token ! "
          }
        } catch {
          Write-Host -ForegroundColor Red "an error occured - vault token"
          Exit 98
        }
        # no token no cookies 
        if ([string]::IsNullOrWhitespace([System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($VAULT_TOKEN)))) { Write-Host -Foreground Red "no token given ... how do you think does an authentification work ?" ; exit 90}
        # get ssh otp from vault 
        $vhead = @{
          'X-Vault-Token' = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($VAULT_TOKEN))
        }
        $VAULT_OTP_REQ=Invoke-RestMethod -Uri $VAULT_SRV/v1/ssh/creds/$VR -Method Post -headers $vhead -Body "{ `"ip`": `"$VI`" }" | ConvertTo-Json | ConvertFrom-Json
        $VAULT_OTP=$VAULT_OTP_REQ.data.key
        # run putty 
        try {
          putty.exe -ssh $VU@$VI -pw $VAULT_OTP
        } catch {
          Write-Host -ForegroundColor Red "putty.exe not find please define the path in enviroment variables"
          Exit 96
        }
      }
    "u" {
      $VUP=Read-Host -AsSecureString "please enter you vault password "
      $VUP_E = [System.Runtime.InteropServices.Marshal]::PtrToStringAuto([System.Runtime.InteropServices.Marshal]::SecureStringToBSTR($VUP))
      try {
        # login vault 
        $VLogIn=Invoke-RestMethod -Uri $VAULT_SRV/v1/auth/userpass/login/$VUU -Method Post -Body "{ `"username`": `"$VUU`" , `"password`": `"$VUP_E`"}" | ConvertTo-Json | ConvertFrom-Json
      } catch {
        Write-Host -ForegroundColor Red "Wrong Password ?"
        Exit 92
      }
      $vhead = @{
        # set token to client_token get from login 
        'X-Vault-Token' = $VLogIn.auth.client_token
      }
      try {
        # get otp password 
        $VAULT_OTP_REQ=Invoke-RestMethod -Uri $VAULT_SRV/v1/ssh/creds/$VR -Method Post -headers $vhead -Body "{ `"ip`": `"$VI`" }" | ConvertTo-Json | ConvertFrom-Json
      } catch {
        Write-Host -ForegroundColor Red "could not get client_token"
        Exit 93
      }
      $VAULT_OTP=$VAULT_OTP_REQ.data.key
       # run putty 
       try {
        putty.exe -ssh $VU@$VI -pw $VAULT_OTP
       } catch {
        Write-Host -ForegroundColor Red "putty.exe not find please define the path in enviroment variables"
        Exit 96
      }
  }
}

Quellen :
https://www.hashicorp.com/

Skript zum Abfragen der Mitglieder in einer dynamischen Verteilerlisten:

Add-PSSnapin Microsoft.Exchange.Management.PowerShell.SnapIn
$DDL = “Name-der-Verteilerliste”
Get-DynamicDistributionGroup $DDL | ForEach {Get-Recipient -RecipientPreviewFilter $_.RecipientFilter -OrganizationalUnit $_.RecipientContainer} | Select DisplayName,PrimarySMTPAddress | Format-Table 

Hinweis: Die erste Zeile braucht man nur, wenn das Powershell-Skript außerhalb der Exchange-Powershell laufen lässt. Diese lädt die Exchange-Verwaltungsmodule!