Telemetry

contrib/win32/openssh/MicrosoftTelemetry.h

@@ -0,0 +1,87 @@
+/* ++
+
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the MIT License. See LICENSE in the project root for license information.
+
+Module Name:
+
+    TraceLoggingConfig.h
+
+Abstract:
+
+    Macro definitions used by this project's TraceLogging ETW providers:
+
+    - Configuration macros that select the ETW Provider Groups to be used by
+      this project.
+    - Constants for tags that are commonly used in Microsoft's
+      TraceLogging-based ETW.
+
+    Different versions of this file use different definitions for the
+    TraceLoggingOption configuration macros. The definitions in this file are
+    empty. As a result, providers using this configuration file will not join
+    any ETW Provider Groups and will not be given any special treatment by
+    group-sensitive ETW listeners.
+
+Environment:
+
+    User mode or kernel mode.
+
+--*/
+
+#pragma once
+
+// Configuration macro for use in TRACELOGGING_DEFINE_PROVIDER. The definition
+// in this file configures the provider as a normal (non-telemetry) provider.
+#define TraceLoggingOptionMicrosoftTelemetry() \
+    // Empty definition for TraceLoggingOptionMicrosoftTelemetry
+
+// Configuration macro for use in TRACELOGGING_DEFINE_PROVIDER. The definition
+// in this file configures the provider as a normal (non-telemetry) provider.
+#define TraceLoggingOptionWindowsCoreTelemetry() \
+    // Empty definition for TraceLoggingOptionWindowsCoreTelemetry
+
+// Event privacy tags. Use the PDT macro values for the tag parameter, e.g.:
+// TraceLoggingWrite(...,
+//   TelemetryPrivacyDataTag(PDT_BrowsingHistory | PDT_ProductAndServiceUsage),
+//   ...);
+#define TelemetryPrivacyDataTag(tag) TraceLoggingUInt64((tag), "PartA_PrivTags")
+#define PDT_BrowsingHistory                    0x0000000000000002u
+#define PDT_DeviceConnectivityAndConfiguration 0x0000000000000800u
+#define PDT_InkingTypingAndSpeechUtterance     0x0000000000020000u
+#define PDT_ProductAndServicePerformance       0x0000000001000000u
+#define PDT_ProductAndServiceUsage             0x0000000002000000u
+#define PDT_SoftwareSetupAndInventory          0x0000000080000000u
+
+// Event categories specified via keywords, e.g.:
+// TraceLoggingWrite(...,
+//     TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+//     ...);
+#define MICROSOFT_KEYWORD_CRITICAL_DATA 0x0000800000000000 // Bit 47
+#define MICROSOFT_KEYWORD_MEASURES      0x0000400000000000 // Bit 46
+#define MICROSOFT_KEYWORD_TELEMETRY     0x0000200000000000 // Bit 45
+#define MICROSOFT_KEYWORD_RESERVED_44   0x0000100000000000 // Bit 44 (reserved for future assignment)
+
+// Event categories specified via event tags, e.g.:
+// TraceLoggingWrite(...,
+//     TraceLoggingEventTag(MICROSOFT_EVENTTAG_REALTIME_LATENCY),
+//     ...);
+#define MICROSOFT_EVENTTAG_DROP_USER_IDS            0x00008000
+#define MICROSOFT_EVENTTAG_AGGREGATE                0x00010000
+#define MICROSOFT_EVENTTAG_DROP_PII_EXCEPT_IP       0x00020000
+#define MICROSOFT_EVENTTAG_COSTDEFERRED_LATENCY     0x00040000
+#define MICROSOFT_EVENTTAG_CORE_DATA                0x00080000
+#define MICROSOFT_EVENTTAG_INJECT_XTOKEN            0x00100000
+#define MICROSOFT_EVENTTAG_REALTIME_LATENCY         0x00200000
+#define MICROSOFT_EVENTTAG_NORMAL_LATENCY           0x00400000
+#define MICROSOFT_EVENTTAG_CRITICAL_PERSISTENCE     0x00800000
+#define MICROSOFT_EVENTTAG_NORMAL_PERSISTENCE       0x01000000
+#define MICROSOFT_EVENTTAG_DROP_PII                 0x02000000
+#define MICROSOFT_EVENTTAG_HASH_PII                 0x04000000
+#define MICROSOFT_EVENTTAG_MARK_PII                 0x08000000
+
+// Field categories specified via field tags, e.g.:
+// TraceLoggingWrite(...,
+//     TraceLoggingString(szUser, "UserName", "User's name", MICROSOFT_FIELDTAG_HASH_PII),
+//     ...);
+#define MICROSOFT_FIELDTAG_DROP_PII 0x04000000
+#define MICROSOFT_FIELDTAG_HASH_PII 0x08000000

contrib/win32/openssh/OpenSSHBuildHelper.psm1

@@ -205,13 +205,14 @@ function Start-OpenSSHBootstrap
     }    
 
     $vcVars = "${env:ProgramFiles(x86)}\Microsoft Visual Studio 14.0\Common7\Tools\vsvars32.bat"
-    $sdkPath = "${env:ProgramFiles(x86)}\Windows Kits\8.1\bin\x86\register_app.vbs"    
+    $sdkPath = Get-Windows10SDKVersion
+    $vctargetspath = "${env:ProgramFiles(x86)}\Program Files (x86)\MSBuild\Microsoft.Cpp\v4.0\v140"
     #use vs2017 build tool if exists
     if($VS2017Path -ne $null)
     {
-        If (-not (Test-Path $sdkPath))
+        If ($sdkPath -eq $null)
         {
-            $packageName = "windows-sdk-8.1"
+            $packageName = "windows-sdk-10.1"
             Write-BuildMsg -AsInfo -Message "$packageName not present. Installing $packageName ..."
             choco install $packageName -y --force --limitoutput --execution-timeout 10000 2>&1 >> $script:BuildLogFile
         }
@@ -221,10 +222,10 @@ function Start-OpenSSHBootstrap
             Write-BuildMsg -AsError -ErrorAction Stop -Message "VC++ 2015.3 v140 toolset are not installed."   
         }
     }
-    elseIf (($VS2015Path -eq $null) -or (-not (Test-Path $VcVars)) -or (-not (Test-Path $sdkPath))) {
+    elseIf (($VS2015Path -eq $null) -or (-not (Test-Path $VcVars)) -or (-not (Test-Path $vctargetspath)) -or ($sdkPath -eq $null)) {
         $packageName = "vcbuildtools"
         Write-BuildMsg -AsInfo -Message "$packageName not present. Installing $packageName ..."
-        choco install $packageName -ia "/InstallSelectableItems VisualCppBuildTools_ATLMFC_SDK;VisualCppBuildTools_NETFX_SDK;Win81SDK_CppBuildSKUV1" -y --force --limitoutput --execution-timeout 10000 2>&1 >> $script:BuildLogFile
+        choco install $packageName -ia "/InstallSelectableItems VisualCppBuildTools_ATLMFC_SDK;VisualCppBuildTools_NETFX_SDK;Win10SDK_VisibleV1" -y --force --limitoutput --execution-timeout 10000 2>&1 >> $script:BuildLogFile
         $errorCode = $LASTEXITCODE
         if ($errorCode -eq 3010)
         {
@@ -574,9 +575,11 @@ function Start-OpenSSHBuild
     if($msbuildCmd -eq $null)
     {
         $msbuildCmd = Get-VS2015BuildToolPath
+        $env:VCTargetsPath=$vctargetspath
     }
 
     Write-BuildMsg -AsInfo -Message "Starting Open SSH build; Build Log: $($script:BuildLogFile)."
+    Write-BuildMsg -AsInfo -Message "$msbuildCmd $cmdMsg"
 
     & "$msbuildCmd" $cmdMsg
     $errorCode = $LASTEXITCODE
@@ -627,12 +630,18 @@ function Get-Windows10SDKVersion
    $windowsSDKPath = Join-Path ${env:ProgramFiles(x86)} "Windows Kits\10\Lib"
    $minSDKVersion = [version]"10.0.14393.0"
    $versionsAvailable = @()
-   #Temporary fix - Onecore builds are failing with latest widows 10 SDK (10.0.18362.0)
+   #Temporary fix - Onecore builds are failing with latest windows 10 SDK (10.0.18362.0)
    $maxSDKVersion = [version]"10.0.17763.0"
    $versionsAvailable = Get-ChildItem $windowsSDKPath | ? {$_.Name.StartsWith("10.")} | % {$version = [version]$_.Name; if(($version.CompareTo($minSDKVersion) -ge 0) -and ($version.CompareTo($maxSDKVersion) -le 0)) {$version}}
-   if(0 -eq $versionsAvailable.count)
+   # when no sdk is found in the specified range
+   if($null -eq $versionsAvailable)
    {
-        return $null
+       return $null
+   }
+   # when there's only one result, the variable is no longer an array
+   if("Version" -eq $versionsAvailable.GetType().Name)
+   {
+       return $versionsAvailable
    }
    $versionsAvailable = $versionsAvailable | Sort-Object -Descending
    return $versionsAvailable[0]

contrib/win32/openssh/config.h.vs

@@ -1715,4 +1715,5 @@
 #define HAVE_LOCALTIME_R
 #define HAVE_DECL_MEMMEM 0
 #define WITH_ZLIB
-#define _PATH_TTY "conin$"
+#define _PATH_TTY "conin$"
+#define WINDOWS_TELEMETRY 0

contrib/win32/openssh/paths.targets

@@ -18,7 +18,7 @@
     <ZLib-arm-Path>$(SolutionDir)\ZLib\bin\arm\</ZLib-arm-Path>
     <UseOpenSSL>true</UseOpenSSL>
     <SSLLib>libcrypto.lib;</SSLLib>
-    <WindowsSDKVersion>8.1</WindowsSDKVersion>
+    <WindowsSDKVersion>10.0.17763.0</WindowsSDKVersion>
     <AdditionalDependentLibs>bcrypt.lib;Userenv.lib;Crypt32.lib;Ws2_32.lib;Secur32.lib;Shlwapi.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;Netapi32.lib;Rpcrt4.lib;ntdll.lib</AdditionalDependentLibs>
     <MinimalCoreWin>false</MinimalCoreWin>
   </PropertyGroup>

contrib/win32/openssh/telemetry.c

@@ -0,0 +1,193 @@
+/* 
+this file defines functions to collect Microsoft Telemetry,
+which will only be sent for Windows In-Box releases. 
+GitHub releases will not send any Telemetry. 
+*/
+
+#include <stdio.h>
+#include <Objbase.h>
+
+#include "telemetry.h"
+#include "telemetryInternal.h"
+
+// {0d986661-0dd7-561a-b15b-fcc1cd46d2bb}
+TRACELOGGING_DEFINE_PROVIDER(
+    g_hProvider1,
+    "Microsoft.Windows.Win32OpenSSH",
+    (0x0d986661, 0x0dd7, 0x561a, 0xb1, 0x5b, 0xfc, 0xc1, 0xcd, 0x46, 0xd2, 0xbb),
+    TraceLoggingOptionMicrosoftTelemetry());
+
+void send_auth_telemetry(const int status, const char* auth_type)
+{
+#ifdef WINDOWS_TELEMETRY
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "Auth",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingInt16(status, "Success"),
+        TraceLoggingString(auth_type, "Auth Type")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+#endif
+}
+
+void send_encryption_telemetry(const char* direction, const char* cipher, const char* kex,
+    const char* mac, const char* comp, const char* host_key, const char** cproposal, const char** sproposal)
+{
+#ifdef WINDOWS_TELEMETRY
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "Encryption",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingString(direction, "direction"),
+        TraceLoggingString(cipher, "cipher"),
+        TraceLoggingString(kex, "kex"),
+        TraceLoggingString(mac, "mac"),
+        TraceLoggingString(comp, "compression"),
+        TraceLoggingString(host_key, "host_key"),
+        TraceLoggingString(cproposal[0], "client proposed kex"),
+        TraceLoggingString(cproposal[1], "client proposed host keys"),
+        TraceLoggingString(cproposal[2], "client proposed ciphers ctos"),
+        TraceLoggingString(cproposal[3], "client proposed ciphers stoc"),
+        TraceLoggingString(cproposal[4], "client proposed MACs ctos"),
+        TraceLoggingString(cproposal[5], "client proposed MACs stoc"),
+        TraceLoggingString(cproposal[6], "client proposed compression ctos"),
+        TraceLoggingString(cproposal[7], "client proposed compression stoc"),
+        TraceLoggingString(sproposal[0], "server proposed kex"),
+        TraceLoggingString(sproposal[1], "server proposed host keys"),
+        TraceLoggingString(sproposal[2], "server proposed ciphers ctos"),
+        TraceLoggingString(sproposal[3], "server proposed ciphers stoc"),
+        TraceLoggingString(sproposal[4], "server proposed MACs ctos"),
+        TraceLoggingString(sproposal[5], "server proposed MACs stoc"),
+        TraceLoggingString(sproposal[6], "server proposed compression ctos"),
+        TraceLoggingString(sproposal[7], "server proposed compression stoc")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+#endif
+}
+
+void send_key_telemetry(const char* key)
+{
+#ifdef WINDOWS_TELEMETRY
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "Key",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingString(key, "Status")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+#endif
+}
+
+void send_shell_telemetry(const int pty, const int shell_type)
+{
+#ifdef WINDOWS_TELEMETRY
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "Shell",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingInt16(pty, "PTY"),
+        TraceLoggingInt16(shell_type, "Type")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+#endif
+}
+
+void send_sign_telemetry(const char* sign_status)
+{
+#ifdef WINDOWS_TELEMETRY
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "Signing",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingString(sign_status, "Status")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+#endif
+}
+
+void send_ssh_telemetry(const char* conn)
+{
+#ifdef WINDOWS_TELEMETRY
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "Connection",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingString(conn, "Status")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+#endif
+}
+
+void send_sshd_telemetry(const int num_auth_methods, const char** auth_methods,
+    const unsigned int num_ports, const int ports[])
+{
+#ifdef WINDOWS_TELEMETRY
+    char* auth_buffer = NULL;
+
+
+    if (num_auth_methods == 0) {
+        auth_buffer = (char*)malloc(5 * sizeof(char));
+        strcpy_s(auth_buffer, 5, "none");
+    }
+    else {
+        // concatenate all the auth methods into a 
+        // single string to pass to tracelogging
+        size_t buffer_size = (size_t)num_auth_methods;
+        for (int i = 0; i < num_auth_methods; i++) {
+            buffer_size += strlen(auth_methods[i]);
+        }
+        auth_buffer = (char*)malloc(buffer_size * sizeof(char));
+        auth_buffer[0] = '\0';
+        for (int i = 0; i < num_auth_methods; i++) {
+            strcat_s(auth_buffer, buffer_size, auth_methods[i]);
+            if (i < num_auth_methods - 1) {
+                strcat_s(auth_buffer, buffer_size, ",");
+            }
+        }
+    }
+
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "SSHD",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingInt32Array(ports, num_ports, "Port"),
+        TraceLoggingString(auth_buffer, "Auth Methods")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+    free(auth_buffer);
+#endif
+}
+
+void send_startup_telemetry(const char* ssh_version, const char* peer_version, 
+    const char* remote_protocol_supported)
+{
+#ifdef WINDOWS_TELEMETRY
+    TraceLoggingRegister(g_hProvider1);
+    TraceLoggingWrite(
+        g_hProvider1,
+        "Startup",
+        TelemetryPrivacyDataTag(PDT_ProductAndServiceUsage),
+        TraceLoggingKeyword(MICROSOFT_KEYWORD_MEASURES),
+        TraceLoggingString(ssh_version, " our version"),
+        TraceLoggingString(remote_protocol_supported, "remote protocol error"),
+        TraceLoggingString(peer_version, "peer version")
+    );
+    TraceLoggingUnregister(g_hProvider1);
+#endif
+}
+

contrib/win32/openssh/telemetry.h

@@ -0,0 +1,30 @@
+#pragma once
+
+// sends authentication status & method (key, pw, etc.)
+void send_auth_telemetry(const int status, const char* auth_type);
+
+// sends crypto information like cipher, kex, and mac
+void send_encryption_telemetry(const char* direction, 
+	const char* cipher, const char* kex, const char* mac, 
+	const char* comp, const char* host_key, 
+	const char** cproposal, const char** sproposal);
+
+// sends status if using key-based auth
+void send_key_telemetry(const char* key);
+
+// sends shell configuration and if pty session is used
+void send_shell_telemetry(const int pty, const int shell_type);
+
+// sends signing status if using key-based auth
+void send_sign_telemetry(const char* sign_status);
+
+// sends connection status from ssh client
+void send_ssh_telemetry(const char* conn);
+
+// sends ports and auth methods configured by sshd
+void send_sshd_telemetry(const int num_auth_methods, const char** auth_methods,
+	const unsigned int num_ports, const int ports[]);
+
+// sends version and peer version from ssh & sshd
+void send_startup_telemetry(const char* ssh_version,
+	const char* peer_version, const char* remote_protocol_supported);