Snap for 13241370 from 0071aa00b17c19d6ab5d9ef44fc2a751838c7820 to 25Q2-release

Change-Id: Idd31390c89443fd8e186a35cf67978159778e470

14 files changed, 353 insertions, 50 deletions

diff --git a/framework/java/android/net/wifi/IWifiScannerListener.aidl b/framework/java/android/net/wifi/IWifiScannerListener.aidl
index bd19ac2d0f..74b22a1bbf 100644
--- a/framework/java/android/net/wifi/IWifiScannerListener.aidl
+++ b/framework/java/android/net/wifi/IWifiScannerListener.aidl
@@ -15,14 +15,14 @@
 
 package android.net.wifi;
 
-import android.net.wifi.WifiScanner;
 import android.net.wifi.ScanResult;
+import android.net.wifi.WifiScanner;
+import com.android.modules.utils.ParceledListSlice;
 
 /**
  * @hide
  */
-oneway interface IWifiScannerListener
-{
+oneway interface IWifiScannerListener {
     void onSuccess();
 
     void onFailure(int reason, String description);
@@ -46,5 +46,5 @@ oneway interface IWifiScannerListener
     /**
      * reports full scan result for all access points found in scan
      */
-    void onFullResults(in List<ScanResult> scanResult);
-}
\ No newline at end of file
+    void onFullResults(in ParceledListSlice<ScanResult> scanResult);
+}
diff --git a/framework/java/android/net/wifi/WifiScanner.java b/framework/java/android/net/wifi/WifiScanner.java
index fd9676e0e4..b5cc3b0976 100644
--- a/framework/java/android/net/wifi/WifiScanner.java
+++ b/framework/java/android/net/wifi/WifiScanner.java
@@ -45,6 +45,7 @@ import android.util.Log;
 import androidx.annotation.RequiresApi;
 
 import com.android.internal.util.Protocol;
+import com.android.modules.utils.ParceledListSlice;
 import com.android.modules.utils.build.SdkLevel;
 import com.android.wifi.flags.Flags;
 
@@ -387,14 +388,14 @@ public class WifiScanner {
          * reports full scan result for all access points found in scan
          */
         @Override
-        public void onFullResults(List<ScanResult> fullScanResult) {
+        public void onFullResults(ParceledListSlice<ScanResult> fullScanResult) {
             Log.i(TAG, "onFullResults");
             if (mActionListener == null) return;
             if (!(mActionListener instanceof ScanListener)) return;
             ScanListener scanListener = (ScanListener) mActionListener;
             Binder.clearCallingIdentity();
             mExecutor.execute(
-                    () -> fullScanResult.forEach(scanListener::onFullResult));
+                    () -> fullScanResult.getList().forEach(scanListener::onFullResult));
         }
 
         @Override
@@ -1021,7 +1022,8 @@ public class WifiScanner {
             dest.writeInt(mFlags);
             dest.writeInt(mBucketsScanned);
             dest.writeInt(mScannedBands);
-            dest.writeParcelableList(mResults, 0);
+            ParceledListSlice<ScanResult> parceledListSlice = new ParceledListSlice<>(mResults);
+            parceledListSlice.writeToParcel(dest, flags);
         }
 
         /** Implement the Parcelable interface {@hide} */
@@ -1032,9 +1034,10 @@ public class WifiScanner {
                         int flags = in.readInt();
                         int bucketsScanned = in.readInt();
                         int bandsScanned = in.readInt();
-                        List<ScanResult> results = new ArrayList<>();
-                        in.readParcelableList(results, ScanResult.class.getClassLoader());
-                        return new ScanData(id, flags, bucketsScanned, bandsScanned, results);
+                        ParceledListSlice<ScanResult> parceledListSlice =
+                                ParceledListSlice.CREATOR.createFromParcel(in);
+                        return new ScanData(id, flags, bucketsScanned, bandsScanned,
+                                parceledListSlice.getList());
                     }
 
                     public ScanData[] newArray(int size) {
diff --git a/framework/java/android/net/wifi/rtt/PasnConfig.java b/framework/java/android/net/wifi/rtt/PasnConfig.java
index 550fa6f5ea..547d94bb67 100644
--- a/framework/java/android/net/wifi/rtt/PasnConfig.java
+++ b/framework/java/android/net/wifi/rtt/PasnConfig.java
@@ -184,7 +184,7 @@ public final class PasnConfig implements Parcelable {
     private final int mBaseAkms;
     @Cipher
     private final int mCiphers;
-    private final String mPassword;
+    private String mPassword;
     private final WifiSsid mWifiSsid;
     private final byte[] mPasnComebackCookie;
 
@@ -213,6 +213,13 @@ public final class PasnConfig implements Parcelable {
     }
 
     /**
+     * @hide
+     */
+    public void setPassword(String password) {
+        mPassword = password;
+    }
+
+    /**
      * Get Wifi SSID which is used to retrieve saved network profile if {@link #getPassword()}
      * is null. If Wifi SSID and password are not set and there is no saved profile corresponding to
      * the responder, unauthenticated PASN will be used if {@link RangingRequest#getSecurityMode()}
diff --git a/framework/java/android/net/wifi/rtt/RangingResult.java b/framework/java/android/net/wifi/rtt/RangingResult.java
index 8ef3d2de08..09d196ab44 100644
--- a/framework/java/android/net/wifi/rtt/RangingResult.java
+++ b/framework/java/android/net/wifi/rtt/RangingResult.java
@@ -197,6 +197,14 @@ public final class RangingResult implements Parcelable {
             mR2iTxLtfRepetitions = other.mR2iTxLtfRepetitions;
             mNumTxSpatialStreams = other.mNumTxSpatialStreams;
             mNumRxSpatialStreams = other.mNumRxSpatialStreams;
+            mIsRangingAuthenticated = other.mIsRangingAuthenticated;
+            mIsRangingFrameProtected = other.mIsRangingFrameProtected;
+            mIsSecureHeLtfEnabled = other.mIsSecureHeLtfEnabled;
+            mSecureHeLtfProtocolVersion = other.mSecureHeLtfProtocolVersion;
+            if (other.mPasnComebackCookie != null) {
+                mPasnComebackCookie = other.mPasnComebackCookie.clone();
+                mPasnComebackAfterMillis = other.mPasnComebackAfterMillis;
+            }
             mVendorData = new ArrayList<>(other.mVendorData);
         }
 
diff --git a/service/java/com/android/server/wifi/WifiConfigManager.java b/service/java/com/android/server/wifi/WifiConfigManager.java
index 3eb3d0ed49..c996782c11 100644
--- a/service/java/com/android/server/wifi/WifiConfigManager.java
+++ b/service/java/com/android/server/wifi/WifiConfigManager.java
@@ -817,6 +817,31 @@ public class WifiConfigManager {
     }
 
     /**
+     * Retrieves the  configured network corresponding to the provided SSID and security type. The
+     * WifiConfiguration object will have the password in plain text.
+     *
+     * WARNING: Don't use this to pass network configurations to external apps. Should only be
+     * sent to system apps/wifi stack, when there is a need for passwords in plaintext.
+     *
+     * @param ssid SSID of the requested network.
+     * @param securityType  security type of the requested network.
+     * @return WifiConfiguration object if found, null otherwise.
+     */
+    public @Nullable WifiConfiguration getConfiguredNetworkWithPassword(@NonNull WifiSsid ssid,
+            @WifiConfiguration.SecurityType int securityType) {
+        List<WifiConfiguration> wifiConfigurations = getConfiguredNetworks(false, false,
+                Process.WIFI_UID);
+        for (WifiConfiguration wifiConfiguration : wifiConfigurations) {
+            // Match ssid and security type
+            if (ssid.equals(WifiSsid.fromString(wifiConfiguration.SSID))
+                    && wifiConfiguration.isSecurityType(securityType)) {
+                return new WifiConfiguration(wifiConfiguration);
+            }
+        }
+        return null;
+    }
+
+    /**
      * Retrieves the list of all configured networks with the passwords masked.
      *
      * @return List of WifiConfiguration objects representing the networks.
diff --git a/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java b/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java
index fd76503220..674e1558a3 100644
--- a/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java
+++ b/service/java/com/android/server/wifi/hal/WifiRttControllerAidlImpl.java
@@ -298,7 +298,8 @@ public class WifiRttControllerAidlImpl implements IWifiRttController {
                     .set80211mcMeasurement(rttResult.type == RttType.TWO_SIDED_11MC)
                     .setMeasurementChannelFrequencyMHz(rttResult.channelFreqMHz)
                     .setMeasurementBandwidth(halToFrameworkChannelBandwidth(rttResult.packetBw))
-                    .set80211azNtbMeasurement(rttResult.type == RttType.TWO_SIDED_11AZ_NTB)
+                    .set80211azNtbMeasurement(rttResult.type == RttType.TWO_SIDED_11AZ_NTB
+                            || rttResult.type == RttType.TWO_SIDED_11AZ_NTB_SECURE)
                     .setMinTimeBetweenNtbMeasurementsMicros(rttResult.ntbMinMeasurementTime
                             * CONVERSION_MICROS_TO_100_MICROS)
                     .setMaxTimeBetweenNtbMeasurementsMicros(rttResult.ntbMaxMeasurementTime
diff --git a/service/java/com/android/server/wifi/rtt/RttService.java b/service/java/com/android/server/wifi/rtt/RttService.java
index aa13c0b6c0..9242992a08 100644
--- a/service/java/com/android/server/wifi/rtt/RttService.java
+++ b/service/java/com/android/server/wifi/rtt/RttService.java
@@ -62,7 +62,8 @@ public class RttService extends SystemService {
 
             mImpl.start(handlerThread.getLooper(), wifiInjector.getClock(), awareManager,
                     rttMetrics, wifiPermissionsUtil, wifiInjector.getSettingsConfigStore(),
-                    wifiInjector.getHalDeviceManager());
+                    wifiInjector.getHalDeviceManager(), wifiInjector.getWifiConfigManager(),
+                    wifiInjector.getSsidTranslator());
         } else if (phase == SystemService.PHASE_BOOT_COMPLETED) {
             mImpl.handleBootCompleted();
         }
diff --git a/service/java/com/android/server/wifi/rtt/RttServiceImpl.java b/service/java/com/android/server/wifi/rtt/RttServiceImpl.java
index 930368e1b0..10cbe18e11 100644
--- a/service/java/com/android/server/wifi/rtt/RttServiceImpl.java
+++ b/service/java/com/android/server/wifi/rtt/RttServiceImpl.java
@@ -38,17 +38,21 @@ import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.location.LocationManager;
 import android.net.MacAddress;
+import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
+import android.net.wifi.WifiSsid;
 import android.net.wifi.aware.IWifiAwareMacAddressProvider;
 import android.net.wifi.aware.MacAddrMapping;
 import android.net.wifi.aware.WifiAwareManager;
 import android.net.wifi.rtt.IRttCallback;
 import android.net.wifi.rtt.IWifiRttManager;
+import android.net.wifi.rtt.PasnConfig;
 import android.net.wifi.rtt.RangingRequest;
 import android.net.wifi.rtt.RangingResult;
 import android.net.wifi.rtt.RangingResultCallback;
 import android.net.wifi.rtt.ResponderConfig;
 import android.net.wifi.rtt.ResponderLocation;
+import android.net.wifi.rtt.SecureRangingConfig;
 import android.net.wifi.rtt.WifiRttManager;
 import android.os.Binder;
 import android.os.Bundle;
@@ -73,7 +77,9 @@ import com.android.server.wifi.BuildProperties;
 import com.android.server.wifi.Clock;
 import com.android.server.wifi.FrameworkFacade;
 import com.android.server.wifi.HalDeviceManager;
+import com.android.server.wifi.SsidTranslator;
 import com.android.server.wifi.SystemBuildProperties;
+import com.android.server.wifi.WifiConfigManager;
 import com.android.server.wifi.WifiSettingsConfigStore;
 import com.android.server.wifi.hal.WifiRttController;
 import com.android.server.wifi.proto.nano.WifiMetricsProto;
@@ -116,8 +122,8 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
     private final BuildProperties mBuildProperties;
     private FrameworkFacade mFrameworkFacade;
     private WifiRttController.Capabilities mCapabilities;
-
     private RttServiceSynchronized mRttServiceSynchronized;
+    private SsidTranslator mWifiSsidTranslator;
 
     /* package */ static final String HAL_RANGING_TIMEOUT_TAG = TAG + " HAL Ranging Timeout";
 
@@ -128,6 +134,7 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
 
     // arbitrary, larger than anything reasonable
     /* package */ static final int MAX_QUEUED_PER_UID = 20;
+    private WifiConfigManager mWifiConfigManager;
 
     private final WifiRttController.RttControllerRangingResultsCallback mRangingResultsCallback =
             new WifiRttController.RttControllerRangingResultsCallback() {
@@ -311,10 +318,14 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
      * @param wifiPermissionsUtil Utility for permission checks.
      * @param settingsConfigStore Used for retrieving verbose logging level.
      * @param halDeviceManager The HAL device manager object.
+     * @param wifiConfigManager The Wi-Fi configuration manager used to retrieve credentials for
+     *                          secure ranging
+     * @param ssidTranslator SSID translator
      */
     public void start(Looper looper, Clock clock, WifiAwareManager awareManager,
             RttMetrics rttMetrics, WifiPermissionsUtil wifiPermissionsUtil,
-            WifiSettingsConfigStore settingsConfigStore, HalDeviceManager halDeviceManager) {
+            WifiSettingsConfigStore settingsConfigStore, HalDeviceManager halDeviceManager,
+            WifiConfigManager wifiConfigManager, SsidTranslator ssidTranslator) {
         mClock = clock;
         mAwareManager = awareManager;
         mHalDeviceManager = halDeviceManager;
@@ -323,6 +334,8 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
         mRttServiceSynchronized = new RttServiceSynchronized(looper);
         mActivityManager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
         mPowerManager = mContext.getSystemService(PowerManager.class);
+        mWifiConfigManager = wifiConfigManager;
+        mWifiSsidTranslator = ssidTranslator;
 
         mRttServiceSynchronized.mHandler.post(() -> {
             IntentFilter intentFilter = new IntentFilter();
@@ -516,6 +529,63 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
         }
     }
 
+    private @WifiConfiguration.SecurityType int getSecurityTypeFromPasnAkms(
+            @PasnConfig.AkmType int akms) {
+        @WifiConfiguration.SecurityType int securityType;
+        // IEEE 802.11az supports PASN authentication with FT, PASN authentication with SAE and
+        // PASN authentication with FILS shared key. On FT PSK and SAE needs pre-shared key or
+        // password.
+        if (akms == PasnConfig.AKM_PASN) {
+            securityType = WifiConfiguration.SECURITY_TYPE_OPEN;
+        } else if ((akms & PasnConfig.AKM_SAE) != 0) {
+            securityType = WifiConfiguration.SECURITY_TYPE_SAE;
+        } else if ((akms & PasnConfig.AKM_FT_PSK_SHA256) != 0
+                || (akms & PasnConfig.AKM_FT_PSK_SHA384) != 0) {
+            // Note: WifiConfiguration is created as PSK. The fast transition (FT) flag is added
+            // before saving to wpa_supplicant. So check for SECURITY_TYPE_PSK.
+            securityType = WifiConfiguration.SECURITY_TYPE_PSK;
+        } else {
+            securityType = WifiConfiguration.SECURITY_TYPE_EAP;
+        }
+        return securityType;
+    }
+
+    /**
+     * Update the PASN password from WifiConfiguration.
+     */
+    private void updatePasswordIfRequired(@NonNull PasnConfig pasnConfig) {
+        if (pasnConfig.getPassword() != null || pasnConfig.getWifiSsid() == null) {
+            return;
+        }
+        int securityType = getSecurityTypeFromPasnAkms(pasnConfig.getBaseAkms());
+        if (securityType == WifiConfiguration.SECURITY_TYPE_SAE
+                || securityType == WifiConfiguration.SECURITY_TYPE_PSK) {
+            // The SSID within PasnConfig is supplied by an 11az secure ranging application,
+            // which doesn't guarantee UTF-8 encoding. Therefore, a UTF-8 conversion step is
+            // necessary before the SSID can be reliably used by service code.
+            WifiSsid translatedSsid = mWifiSsidTranslator.getTranslatedSsid(
+                    pasnConfig.getWifiSsid());
+            WifiConfiguration wifiConfiguration =
+                    mWifiConfigManager.getConfiguredNetworkWithPassword(translatedSsid,
+                            securityType);
+            if (wifiConfiguration != null) {
+                pasnConfig.setPassword(wifiConfiguration.preSharedKey);
+            }
+        }
+    }
+
+    /**
+     * Update the secure ranging parameters if required.
+     */
+    private void updateSecureRangingParams(RangingRequest request) {
+        for (ResponderConfig rttPeer : request.mRttPeers) {
+            SecureRangingConfig secureRangingConfig = rttPeer.getSecureRangingConfig();
+            if (secureRangingConfig != null) {
+                updatePasswordIfRequired(secureRangingConfig.getPasnConfig());
+            }
+        }
+    }
+
     /**
      * Binder interface API to start a ranging operation. Called on binder thread, operations needs
      * to be posted to handler thread.
@@ -620,6 +690,7 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
         }
 
         override11azOverlays(request);
+        updateSecureRangingParams(request);
 
         mRttServiceSynchronized.mHandler.post(() -> {
             WorkSource sourceToUse = ws;
@@ -1381,6 +1452,17 @@ public class RttServiceImpl extends IWifiRttManager.Stub {
                             && !resultForRequest.getVendorData().isEmpty()) {
                         builder.setVendorData(resultForRequest.getVendorData());
                     }
+                    // set secure ranging fields
+                    builder.setRangingFrameProtected(resultForRequest.isRangingFrameProtected())
+                            .setRangingAuthenticated(resultForRequest.isRangingAuthenticated())
+                            .setSecureHeLtfEnabled(resultForRequest.isSecureHeLtfEnabled())
+                            .setSecureHeLtfProtocolVersion(
+                                    resultForRequest.getSecureHeLtfProtocolVersion());
+                    if (resultForRequest.getPasnComebackCookie() != null) {
+                        builder.setPasnComebackCookie(resultForRequest.getPasnComebackCookie());
+                        builder.setPasnComebackAfterMillis(
+                                resultForRequest.getPasnComebackAfterMillis());
+                    }
                     finalResults.add(builder.build());
                 }
             }
diff --git a/service/java/com/android/server/wifi/scanner/WifiScannerInternal.java b/service/java/com/android/server/wifi/scanner/WifiScannerInternal.java
index 713edd792e..7dac6f1264 100644
--- a/service/java/com/android/server/wifi/scanner/WifiScannerInternal.java
+++ b/service/java/com/android/server/wifi/scanner/WifiScannerInternal.java
@@ -26,6 +26,7 @@ import android.os.WorkSource;
 import android.util.Log;
 
 import com.android.internal.annotations.VisibleForTesting;
+import com.android.modules.utils.ParceledListSlice;
 import com.android.server.wifi.WifiThreadRunner;
 
 import java.util.Collections;
@@ -93,9 +94,9 @@ public abstract class WifiScannerInternal {
         }
 
         @Override
-        public void onFullResults(List<ScanResult> fullScanResult) {
-            mWifiThreadRunner.post(() -> fullScanResult.forEach(mScanListener::onFullResult),
-                    TAG + "#onFullResults");
+        public void onFullResults(ParceledListSlice<ScanResult> fullScanResult) {
+            mWifiThreadRunner.post(() -> fullScanResult.getList()
+                            .forEach(mScanListener::onFullResult), TAG + "#onFullResults");
         }
 
         @Override
diff --git a/service/java/com/android/server/wifi/scanner/WifiScanningServiceImpl.java b/service/java/com/android/server/wifi/scanner/WifiScanningServiceImpl.java
index 5392d1a0fa..e8c37cf1b3 100644
--- a/service/java/com/android/server/wifi/scanner/WifiScanningServiceImpl.java
+++ b/service/java/com/android/server/wifi/scanner/WifiScanningServiceImpl.java
@@ -61,6 +61,7 @@ import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.util.Protocol;
 import com.android.internal.util.State;
 import com.android.internal.util.StateMachine;
+import com.android.modules.utils.ParceledListSlice;
 import com.android.modules.utils.build.SdkLevel;
 import com.android.server.wifi.ClientModeImpl;
 import com.android.server.wifi.Clock;
@@ -1740,9 +1741,10 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                 }
                 entry.clientInfo.reportEvent((listener) -> {
                     try {
-                        listener.onFullResults(new ArrayList<>(matchedScanResults));
+                        listener.onFullResults(
+                                new ParceledListSlice<>(new ArrayList<>(matchedScanResults)));
                     } catch (RemoteException e) {
-                        loge("Failed to call onFullResult: " + entry.clientInfo);
+                        loge("Failed to call onFullResults: " + entry.clientInfo);
                     }
                 });
                 matchedScanResults.clear();
@@ -1751,9 +1753,9 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
             for (RequestInfo<Void> entry : mSingleScanListeners) {
                 entry.clientInfo.reportEvent((listener) -> {
                     try {
-                        listener.onFullResults(results);
+                        listener.onFullResults(new ParceledListSlice<>(results));
                     } catch (RemoteException e) {
-                        loge("Failed to call onFullResult: " + entry.clientInfo);
+                        loge("Failed to call onFullResults: " + entry.clientInfo);
                     }
                 });
             }
@@ -1779,7 +1781,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                         // make sure the handler is removed
                         listener.onSingleScanCompleted();
                     } catch (RemoteException e) {
-                        loge("Failed to call onResult: " + entry.clientInfo);
+                        loge("Failed to call onResults: " + entry.clientInfo);
                     }
                 });
             }
@@ -1791,7 +1793,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                     try {
                         listener.onResults(allResults);
                     } catch (RemoteException e) {
-                        loge("Failed to call onResult: " + entry.clientInfo);
+                        loge("Failed to call onResults: " + entry.clientInfo);
                     }
                 });
             }
@@ -2314,9 +2316,10 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                     }
                     entry.clientInfo.reportEvent((listener) -> {
                         try {
-                            listener.onFullResults(new ArrayList<>(matchedResults));
+                            listener.onFullResults(
+                                    new ParceledListSlice<>(new ArrayList<>(matchedResults)));
                         } catch (RemoteException e) {
-                            loge("Failed to call onFullResult: " + ci);
+                            loge("Failed to call onFullResults: " + ci);
                         }
                     });
                 }
@@ -2350,7 +2353,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                         try {
                             listener.onResults(resultsToDeliver);
                         } catch (RemoteException e) {
-                            loge("Failed to call onFullResult: " + ci);
+                            loge("Failed to call onResults: " + ci);
                         }
                     });
                 }
@@ -2364,7 +2367,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                     try {
                         listener.onFailure(reason, description);
                     } catch (RemoteException e) {
-                        loge("Failed to call onFullResult: " + ci);
+                        loge("Failed to call onFailure: " + ci);
                     }
                 });
             }
@@ -3229,7 +3232,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                     try {
                         listener.onPnoNetworkFound(results);
                     } catch (RemoteException e) {
-                        loge("Failed to call onFullResult: " + ci);
+                        loge("Failed to call onPnoNetworkFound: " + ci);
                     }
                 });
             }
@@ -3242,7 +3245,7 @@ public class WifiScanningServiceImpl extends IWifiScanner.Stub {
                     try {
                         listener.onFailure(reason, description);
                     } catch (RemoteException e) {
-                        loge("Failed to call onFullResult: " + ci);
+                        loge("Failed to call onFailure: " + ci);
                     }
                 });
             }
diff --git a/service/tests/wifitests/src/com/android/server/wifi/WifiConfigManagerTest.java b/service/tests/wifitests/src/com/android/server/wifi/WifiConfigManagerTest.java
index 83cff646df..3d25fdada6 100644
--- a/service/tests/wifitests/src/com/android/server/wifi/WifiConfigManagerTest.java
+++ b/service/tests/wifitests/src/com/android/server/wifi/WifiConfigManagerTest.java
@@ -17,6 +17,7 @@
 package com.android.server.wifi;
 
 import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_PSK;
+import static android.net.wifi.WifiConfiguration.SECURITY_TYPE_SAE;
 import static android.net.wifi.WifiManager.AddNetworkResult.STATUS_INVALID_CONFIGURATION_ENTERPRISE;
 
 import static com.android.server.wifi.TestUtil.createCapabilityBitset;
@@ -8502,4 +8503,33 @@ public class WifiConfigManagerTest extends WifiBaseTest {
         result = updateNetworkToWifiConfigManager(config);
         assertFalse(result.isSuccess());
     }
+
+    /**
+     * Verify that the configured network with password is correctly retrieved using SSID and Key
+     * management.
+     */
+    @Test
+    public void testConfiguredNetworkWithPassword() {
+
+        NetworkSelectionStatus.Builder builder = new NetworkSelectionStatus.Builder();
+        NetworkSelectionStatus networkSelectionStatus = builder.build();
+        SecurityParams params = SecurityParams.createSecurityParamsBySecurityType(
+                SECURITY_TYPE_SAE);
+        networkSelectionStatus.setCandidateSecurityParams(params);
+        WifiConfiguration saeNetwork = WifiConfigurationTestUtil.createSaeNetwork(TEST_SSID);
+        saeNetwork.setNetworkSelectionStatus(networkSelectionStatus);
+        NetworkUpdateResult result  = verifyAddNetworkToWifiConfigManager(saeNetwork);
+
+        // Get the configured network with password
+        WifiConfiguration wifiConfig = mWifiConfigManager.getConfiguredNetworkWithPassword(
+                WifiSsid.fromString(TEST_SSID), SECURITY_TYPE_SAE);
+        // Test the retrieved network is the same network that was added for TEST_SSID and SAE
+        assertNotNull(wifiConfig);
+        assertEquals(saeNetwork.networkId, result.getNetworkId());
+        assertEquals(WifiConfigurationTestUtil.TEST_PSK, wifiConfig.preSharedKey);
+        wifiConfig = mWifiConfigManager.getConfiguredNetworkWithPassword(
+                WifiSsid.fromString(TEST_SSID), SECURITY_TYPE_PSK);
+        // Test there is no network with TEST_SSID and FT_PSK
+        assertNull(wifiConfig);
+    }
 }
diff --git a/service/tests/wifitests/src/com/android/server/wifi/hal/WifiRttControllerAidlImplTest.java b/service/tests/wifitests/src/com/android/server/wifi/hal/WifiRttControllerAidlImplTest.java
index d2be3f163c..16eec8465d 100644
--- a/service/tests/wifitests/src/com/android/server/wifi/hal/WifiRttControllerAidlImplTest.java
+++ b/service/tests/wifitests/src/com/android/server/wifi/hal/WifiRttControllerAidlImplTest.java
@@ -554,6 +554,84 @@ public class WifiRttControllerAidlImplTest extends WifiBaseTest {
                 equalTo(ScanResult.CHANNEL_WIDTH_80MHZ));
         verifyNoMoreInteractions(mIWifiRttControllerMock);
     }
+
+    /**
+     * Validate correct 11az NTB secure result conversion from HAL to framework.
+     */
+    @Test
+    public void test11azNtbSecureRangeResults() throws Exception {
+        int cmdId = 55;
+        RttResult[] results = new RttResult[1];
+        RttResult res = createRttResult();
+        res.type = RttType.TWO_SIDED_11AZ_NTB_SECURE;
+        res.addr = MacAddress.byteAddrFromStringAddr("05:06:07:08:09:0A");
+        res.ntbMaxMeasurementTime = 10; // 10 * 10000 us = 100000 us
+        res.ntbMinMeasurementTime = 100; // 100 * 100 us = 10000 us
+        res.numRxSpatialStreams = 2;
+        res.numTxSpatialStreams = 3;
+        res.i2rTxLtfRepetitionCount = 3;
+        res.r2iTxLtfRepetitionCount = 2;
+        res.status = RttStatus.SUCCESS;
+        res.distanceInMm = 1500;
+        res.timeStampInUs = 6000;
+        res.packetBw = RttBw.BW_80MHZ;
+        // Fill in secure ranging results
+        res.pasnComebackAfterMillis = 1000;
+        res.baseAkm  = Akm.PASN | Akm.SAE;
+        res.isRangingFrameProtectionEnabled = true;
+        res.isSecureLtfEnabled = true;
+        res.secureHeLtfProtocolVersion = 1;
+        res.pasnComebackCookie = new byte[] {1, 2, 3};
+        results[0] = res;
+
+        // (1) have the HAL call us with results
+        mEventCallbackCaptor.getValue().onResults(cmdId, results);
+
+        // (2) verify call to framework
+        verify(mRangingResultsCallbackMock).onRangingResults(eq(cmdId), mRttResultCaptor.capture());
+
+        // verify contents of the framework results
+        List<RangingResult> rttR = mRttResultCaptor.getValue();
+
+        collector.checkThat("number of entries", rttR.size(), equalTo(1));
+
+        RangingResult rttResult = rttR.get(0);
+        collector.checkThat("Type", rttResult.is80211azNtbMeasurement(), equalTo(true));
+        collector.checkThat("status", rttResult.getStatus(),
+                equalTo(WifiRttController.FRAMEWORK_RTT_STATUS_SUCCESS));
+        collector.checkThat("mac", rttResult.getMacAddress().toByteArray(),
+                equalTo(MacAddress.fromString("05:06:07:08:09:0A").toByteArray()));
+        collector.checkThat("ntbMaxMeasurementTime",
+                rttResult.getMaxTimeBetweenNtbMeasurementsMicros(), equalTo(100000L));
+        collector.checkThat("ntbMinMeasurementTime",
+                rttResult.getMinTimeBetweenNtbMeasurementsMicros(), equalTo(10000L));
+        collector.checkThat("numRxSpatialStreams", rttResult.get80211azNumberOfRxSpatialStreams(),
+                equalTo(2));
+        collector.checkThat("numTxSpatialStreams", rttResult.get80211azNumberOfTxSpatialStreams(),
+                equalTo(3));
+        collector.checkThat("i2rTxLtfRepetitionCount",
+                rttResult.get80211azInitiatorTxLtfRepetitionsCount(), equalTo(3));
+        collector.checkThat("r2iTxLtfRepetitionCount",
+                rttResult.get80211azResponderTxLtfRepetitionsCount(), equalTo(2));
+        collector.checkThat("distanceCm", rttResult.getDistanceMm(), equalTo(1500));
+        collector.checkThat("timestamp", rttResult.getRangingTimestampMillis(), equalTo(6L));
+        collector.checkThat("channelBw", rttResult.getMeasurementBandwidth(),
+                equalTo(ScanResult.CHANNEL_WIDTH_80MHZ));
+        // check secure ranging parameters
+        collector.checkThat("pasnComebackAfterMillis", rttResult.getPasnComebackAfterMillis(),
+                equalTo(1000L));
+        collector.checkThat("baseAkm", rttResult.isRangingAuthenticated(), equalTo(true));
+        collector.checkThat("isRangingFrameProtectionEnabled", rttResult.isRangingFrameProtected(),
+                equalTo(true));
+        collector.checkThat("isSecureLtfEnabled", rttResult.isSecureHeLtfEnabled(), equalTo(true));
+        collector.checkThat("secureHeLtfProtocolVersion", rttResult.getSecureHeLtfProtocolVersion(),
+                equalTo(1));
+        collector.checkThat("pasnComebackCookie", rttResult.getPasnComebackCookie(),
+                equalTo(new byte[]{1, 2, 3}));
+        verifyNoMoreInteractions(mIWifiRttControllerMock);
+    }
+
+
     /**
      * Validate correct cleanup when a null array of results is provided by HAL.
      */
diff --git a/service/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java b/service/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
index cc570c77c7..e63c67512f 100644
--- a/service/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
+++ b/service/tests/wifitests/src/com/android/server/wifi/rtt/RttServiceImplTest.java
@@ -23,10 +23,12 @@ import static android.net.wifi.rtt.WifiRttManager.CHARACTERISTICS_KEY_BOOLEAN_ON
 
 import static com.android.server.wifi.WifiSettingsConfigStore.WIFI_VERBOSE_LOGGING_ENABLED;
 import static com.android.server.wifi.rtt.RttTestUtils.compareListContentsNoOrdering;
+import static com.android.server.wifi.rtt.RttTestUtils.getDummyRangingResults;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotEquals;
+import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assume.assumeTrue;
 import static org.mockito.ArgumentMatchers.any;
@@ -55,7 +57,9 @@ import android.content.Intent;
 import android.content.pm.PackageManager;
 import android.location.LocationManager;
 import android.net.MacAddress;
+import android.net.wifi.WifiConfiguration;
 import android.net.wifi.WifiManager;
+import android.net.wifi.WifiSsid;
 import android.net.wifi.aware.IWifiAwareMacAddressProvider;
 import android.net.wifi.aware.MacAddrMapping;
 import android.net.wifi.aware.PeerHandle;
@@ -84,7 +88,9 @@ import com.android.modules.utils.build.SdkLevel;
 import com.android.server.wifi.Clock;
 import com.android.server.wifi.HalDeviceManager;
 import com.android.server.wifi.MockResources;
+import com.android.server.wifi.SsidTranslator;
 import com.android.server.wifi.WifiBaseTest;
+import com.android.server.wifi.WifiConfigManager;
 import com.android.server.wifi.WifiSettingsConfigStore;
 import com.android.server.wifi.hal.WifiRttController;
 import com.android.server.wifi.proto.nano.WifiMetricsProto;
@@ -178,6 +184,11 @@ public class RttServiceImplTest extends WifiBaseTest {
 
     @Mock
     WifiSettingsConfigStore mWifiSettingsConfigStore;
+    @Mock
+    WifiConfigManager mWifiConfigManager;
+    WifiConfiguration mWifiConfiguration = new WifiConfiguration();
+    @Mock
+    SsidTranslator mSsidTranslator;
 
     /**
      * Using instead of spy to avoid native crash failures - possibly due to
@@ -248,7 +259,8 @@ public class RttServiceImplTest extends WifiBaseTest {
         doAnswer(mBinderUnlinkToDeathCounter).when(mockIbinder).unlinkToDeath(any(), anyInt());
 
         mDut.start(mMockLooper.getLooper(), mockClock, mockAwareManager, mockMetrics,
-                mockPermissionUtil, mWifiSettingsConfigStore, mockHalDeviceManager);
+                mockPermissionUtil, mWifiSettingsConfigStore, mockHalDeviceManager,
+                mWifiConfigManager, mSsidTranslator);
         mMockLooper.dispatchAll();
         ArgumentCaptor<BroadcastReceiver> bcastRxCaptor = ArgumentCaptor.forClass(
                 BroadcastReceiver.class);
@@ -371,6 +383,59 @@ public class RttServiceImplTest extends WifiBaseTest {
     }
 
     /**
+     * Validate a successful secure ranging flow.
+     */
+    @Test
+    public void testSecureRanging() throws RemoteException {
+        RangingRequest request = RttTestUtils.getDummySecureRangingRequest(
+                RangingRequest.SECURITY_MODE_OPPORTUNISTIC);
+        mWifiConfiguration.preSharedKey = "TEST_PASSWORD";
+        WifiSsid ssid = request.mRttPeers.get(
+                1).getSecureRangingConfig().getPasnConfig().getWifiSsid();
+        when(mWifiConfigManager.getConfiguredNetworkWithPassword(eq(ssid),
+                eq(WifiConfiguration.SECURITY_TYPE_SAE))).thenReturn(mWifiConfiguration);
+        when(mSsidTranslator.getTranslatedSsid(eq(ssid))).thenReturn(ssid);
+
+        // Make sure the second peer is configured with no password for SAE.
+        assertNull(request.mRttPeers.get(1).getSecureRangingConfig().getPasnConfig().getPassword());
+
+        ClockAnswer clock = new ClockAnswer();
+        doAnswer(clock).when(mockClock).getWallClockMillis();
+        clock.time = 100;
+        mDut.startRanging(mockIbinder, mPackageName, mFeatureId, null, request, mockCallback,
+                mExtras);
+        mMockLooper.dispatchAll();
+        verify(mockRttControllerHal).rangeRequest(mIntCaptor.capture(), mRequestCaptor.capture());
+        verifyWakeupSet(false, 0);
+        RangingRequest halRequest = mRequestCaptor.getValue();
+        assertNotEquals("Request to WifiRttController is not null", null, halRequest);
+        assertEquals("Size of request", request.mRttPeers.size(), halRequest.mRttPeers.size());
+
+        for (int i = 0; i < request.mRttPeers.size(); ++i) {
+            assertEquals("SecureRangingConfig is not same",
+                    request.mRttPeers.get(i).getSecureRangingConfig(),
+                    halRequest.mRttPeers.get(i).getSecureRangingConfig());
+        }
+
+        // Make sure password is set for second peer from WifiConfiguration for the SAE.
+        assertEquals("Password is not set", "TEST_PASSWORD", halRequest.mRttPeers.get(
+                1).getSecureRangingConfig().getPasnConfig().getPassword());
+
+        // Verify ranging results are processed correctly
+        Pair<List<RangingResult>, List<RangingResult>> resultsPair = getDummyRangingResults(
+                halRequest);
+        mRangingResultsCbCaptor.getValue().onRangingResults(mIntCaptor.getValue(),
+                resultsPair.first);
+        mMockLooper.dispatchAll();
+        verify(mockCallback).onRangingResults(mListCaptor.capture());
+        assertTrue(compareListContentsNoOrdering(resultsPair.second, mListCaptor.getValue()));
+
+        verifyWakeupCancelled();
+        verifyNoMoreInteractions(mockRttControllerHal, mockCallback,
+                mAlarmManager.getAlarmManager());
+    }
+
+    /**
      * Validate a successful ranging flow with PeerHandles (i.e. verify translations)
      */
     @Test
diff --git a/service/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java b/service/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java
index d7e8afbf40..d19f79b851 100644
--- a/service/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java
+++ b/service/tests/wifitests/src/com/android/server/wifi/rtt/RttTestUtils.java
@@ -114,6 +114,7 @@ public class RttTestUtils {
         // SAE with no password configured
         pasnConfig = new PasnConfig
                 .Builder(PasnConfig.AKM_SAE, PasnConfig.CIPHER_GCMP_256)
+                .setWifiSsid(WifiSsid.fromString("\"TEST_SSID\""))
                 .build();
         secureRangingConfig = new SecureRangingConfig
                 .Builder(pasnConfig)
@@ -121,7 +122,7 @@ public class RttTestUtils {
                 .setSecureHeLtfEnabled(true)
                 .build();
         config = new ResponderConfig.Builder()
-                .setMacAddress(MacAddress.fromString("00:11:22:33:44:55"))
+                .setMacAddress(MacAddress.fromString("00:11:22:33:44:56"))
                 .setResponderType(ResponderConfig.RESPONDER_AP)
                 .setChannelWidth(ScanResult.CHANNEL_WIDTH_80MHZ)
                 .setPreamble(ScanResult.PREAMBLE_HE)
@@ -139,7 +140,7 @@ public class RttTestUtils {
                 .build();
         config = new ResponderConfig
                 .Builder()
-                .setMacAddress(MacAddress.fromString("00:11:22:33:44:56"))
+                .setMacAddress(MacAddress.fromString("00:11:22:33:44:57"))
                 .setResponderType(ResponderConfig.RESPONDER_AP)
                 .setChannelWidth(ScanResult.CHANNEL_WIDTH_80MHZ)
                 .setPreamble(ScanResult.PREAMBLE_HE)
@@ -151,7 +152,7 @@ public class RttTestUtils {
         // Open mode
         config = new ResponderConfig
                 .Builder()
-                .setMacAddress(MacAddress.fromString("00:11:22:33:44:57"))
+                .setMacAddress(MacAddress.fromString("00:11:22:33:44:58"))
                 .setResponderType(ResponderConfig.RESPONDER_AP)
                 .setChannelWidth(ScanResult.CHANNEL_WIDTH_80MHZ)
                 .setPreamble(ScanResult.PREAMBLE_HE)
@@ -269,19 +270,6 @@ public class RttTestUtils {
 
         if (request != null) {
             for (ResponderConfig peer : request.mRttPeers) {
-                halResults.add(new RangingResult.Builder()
-                        .setStatus(RangingResult.STATUS_SUCCESS)
-                        .setMacAddress(peer.getMacAddress())
-                        .setDistanceMm(rangeCmBase)
-                        .setDistanceStdDevMm(rangeStdDevCmBase)
-                        .setRssi(rssiBase)
-                        .setNumAttemptedMeasurements(8)
-                        .setNumSuccessfulMeasurements(5)
-                        .setRangingTimestampMillis(rangeTimestampBase)
-                        .set80211mcMeasurement(true)
-                        .setMeasurementChannelFrequencyMHz(5180)
-                        .setMeasurementBandwidth(ScanResult.CHANNEL_WIDTH_40MHZ)
-                        .build());
                 RangingResult.Builder builder = new RangingResult.Builder()
                         .setStatus(RangingResult.STATUS_SUCCESS)
                         .setDistanceMm(rangeCmBase++)
@@ -293,13 +281,24 @@ public class RttTestUtils {
                         .set80211mcMeasurement(true)
                         .setMeasurementChannelFrequencyMHz(5180)
                         .setMeasurementBandwidth(ScanResult.CHANNEL_WIDTH_40MHZ);
+                if (peer.getSecureRangingConfig() != null) {
+                    builder.setRangingAuthenticated(true);
+                    builder.setRangingFrameProtected(true);
+                    builder.setSecureHeLtfEnabled(true);
+                    builder.setSecureHeLtfProtocolVersion(1);
+                }
+                halResults.add(builder.setMacAddress(peer.getMacAddress()).build());
                 if (peer.peerHandle == null) {
                     builder.setMacAddress(peer.getMacAddress());
                 } else {
+                    // Make sure MAC address null when peer handle is set.
+                    builder.setMacAddress(null);
                     builder.setPeerHandle(peer.peerHandle);
                 }
-                RangingResult rangingResult = builder.build();
-                results.add(rangingResult);
+                results.add(builder.build());
+                rangeCmBase++;
+                rangeStdDevCmBase++;
+                rssiBase++;
             }
         } else {
             results.add(new RangingResult.Builder()