分类：信息安全

Tesla Motors Logo:

这位白帽黑客名叫 Sam Curry. Curry 发现的这个跨站脚本攻击漏洞 (XSS) 可以被用来非授权地获取车辆信息，例如车辆的 VIN, 速度，温度，是否锁定，胎压，警报，时区等信息。Curry 在自己的 Tesla 汽车上利用 XSS Hunter 的攻击载荷对该漏洞进行了攻击，获取到了如下信息：

VIN: 5YJ3E13374KF2313373

Car Type: 3 P74D

Birthday: Mon Mar 11 16:31:37 2019

Car Version: develop-2019.20.1-203-991337d

Car Computer: ice

SOE / USOE: 48.9, 48.9 %

SOC: 54.2 %

Ideal energy remaining: 37.2 kWh

Range: 151.7 mi

Odometer: 4813.7 miles

Gear: D

Speed: 81 mph

Local Time: Wed Jun 19 15:09:06 2019

UTC Offset: -21600

Timezone: Mountain Daylight Time

BMS State: DRIVE

12V Battery Voltage: 13.881 V

12V Battery Current: 0.13 A

Locked?: true

UI Mode: comfort

Language: English

Service Alert: 0X0

https://samcurry.net/cracking-my-windshield-and-earning-10000-on-the-tesla-bug-bounty-program/

Tesla Model 3:

Curry 随后把该漏洞报告给了 Tesla 的漏洞奖金程序，在大约 12 小时之后，Tesla 即推出了针对该漏洞的热更新。Tesla 认为这是一个严重漏洞，并在两周之后向 Curry 支付了 $10, 000 的漏洞奖金。

安全公司 McAfee 创始人 John McAfee 于 2019 年 06 月 12 日在 Twitter 上发推表示，McAfeeMagic.com 使用的亚马逊 AWS 服务器遭遇了 “cloaked hoic DOS” 攻击，并且自己发自内心地感谢黑客的免费宣传：

John McAfee 说，亚马逊的 AWS 正在学习攻击流量的行为，攻击流量越大，网站恢复得越快：

2019 年 06 月 12 日下午 4 点 18 分，John McAfee 在 Twitter 上宣布 McAfeeMagic.com 已经恢复访问，截至本文发出时，McAfeeMagic.com 仍可以正常访问：

操作环境

操作系统：Windows 10 家庭版 64 位

Android Studio 版本如图 1：

说明

Android Studio 的版本经历了几次更新，导致 ADM (Android Device Monitor) 的打开方式也发生了几次变化，因此，在网络上找怎么打开 ADM 的话可能会发现没法在自己的 Android Studio 上重现他们的方法，这主要是 Android Studio 的版本不同导致的，建议大家在参考本文的时候也查看一下自己的 Android Studio 的版本(我的文章基本都会注明“操作环境”). 但是，版本不同不表示操作方法一定不同，具体还需要根据实际情况确定。

Google 从 Android Studio 3.2 开始就完全弃用了 Android Device Monitor, 相关解释的原文地址如下：

https://developer.android.com/studio/profile/monitor

相关解释的原文摘抄如下：

Android Device Monitor was deprecated in Android Studio 3.1 and removed from Android Studio 3.2. The features that you could use through the Android Device Monitor have been replaced by new features. The table below helps you decide which features you should use instead of these deprecated and removed features.

来自：https://developer.android.com/studio/profile/monitor

参考中文译文如下：

Android Device Monitor (ADM) 从 Android Studio 3.1 开始不赞成使用，在 Android Studio 3.2 上已经移除了 Android Device Monitor. 你之前可以在 Android Device Monitor 上使用的功能都被新的功能代替了。下面的表格将帮助你判定哪些功能是被替换和移除了。

译自：https://developer.android.com/studio/profile/monitor

不过，ADM (Android Device Monitor) 在 Android Studio 3.4.1 版本中仍然存在。此外，目前网络上大部分介绍在 Android Studio 中打开 Android 虚拟机中的文件的方式仍然是使用 ADM 的 File Explorer. 所以，知道如何打开 ADM 仍然很有必要，接下来就是具体的操作步骤。

操作步骤

根据 Android Studio 官网的信息，下面的操作步骤适用于 Android Studio 3.1 及其之后的版本。

使用 Everything 搜索 “sdk\tools” 可以找到 Android SDK 的路径：

或者在 Android Studio 中依次打开 “File / Settings / Android SDK” 中查看 Android SDK 的路径：

在 CMD 中进入 Android SDK tools所在的路径并输入 monitor 指令，即可打开 Android Device Monitor:

Android Device Monitor 的界面：

EOF

freeCodeCamp 是一个帮助人们免费学习代码的平台，用户可以在该平台上免费观看视频，阅读文章，参与互动课程，这些都是免费且公开的。而且，freeCodeCamp 上还有遍布全世界的学习群组可以加入。

freeCodeCamp 没有广告，也没有付费模式，主要收入应该是来自用户捐赠。

freeCodeCamp 从 2015 年开始在 Medium 上面发布文章，并且至今已累计发布约 5000 篇文章。但是随着 Medium 转移到付费模式并且开始重点推荐付费文章，这使得 freeCodeCamp 在 Medium 上的免费文章的流量来源不再主要是 Medium 自身，而是 Google 和社交媒体。

由于 freeCodeCamp 不想把文章设置为付费文章，因此 freeCodeCamp 决定搭建自己的网站，并为此发布了一篇说明文章：

We just moved off of Medium and onto freeCodeCamp News. Here’s how you can use it

根据介绍，freeCodeCamp 应该是使用 Ghost 搭建的新平台 (open source Ghost blogging platform), 在过去的一年里，freeCodeCamp 也把文章都迁移到了新平台。

freeCodeCamp 的网站应该还在不断完善中，目前打开”https://www.freecodecamp.rocks/“显示的是下面这个界面：

不过”https://www.freecodecamp.org/“是可以正常使用的：

冒泡排序算法的排序过程

（以下排序过程按照大数位于小数右边的规则展开说明，按照大数位于小数左边的规则进行的冒泡排序与此过程类似）

1. 首先进行第 1 次遍历，选取整个队列 (队列长度为 N) 的第 1 个数字 (记为 a)，和紧邻 a 后的数字 (记为 b) 比较大小，如果 a 大于 b, 则交换 a 与 b 的位置，此后，a 继续和紧邻 a 后的数字 c 比较；如果 a 小于 b, 则丢下 a, 拿起 b, 并和紧邻 b 后的后的数字比较大小。经过这一轮比较，当比较到整个队列结束时，一共进行了 N-1 次比较，此时，整个队列中最大的数字排在了整个队列的最后；
2. 现在进行第 2 次遍历，此时只需要遍历除了第 1 次遍历后得到的数列的最后一个数之外的 N-1 个数字，即需要比较 N-2 次，得到整个数列第 2 大的数字排在上一轮排序得到的最大的数字的左边；
3. 依照前面两步所示的规则继续进行第 3, 4, 5, …, N-1 轮循环就完成了整个排序过程。

以数列 [3,2,5,1,2] 为例，冒泡排序的过程如下：

第 1 轮第 1 次比较：[2,3,5,1,2];
第 1 轮第 2 次比较：[2,3,5,1,2];
第 1 轮第 3 次比较：[2,3,1,5,2];
第 1 轮结束：[3,2,1,2,5];
第 2 轮结束：[2,1,2,3,5];
第 3 轮结束：[1,2,2,3,5];
第 4 轮结束：[1,2,2,3,5].

下面这个动图很好的演示了冒泡排序的整个过程：
（该动图使用 VisuAlgo 制作，来自：https://visualgo.net/）

C++ 实现的冒泡排序算法

递归实现

#include <iostream>
using namespace std;

int * mp(int a[], int start, int end){
    if(start<end){
/*
使用start和end这两个变量定义递归的边界条件，
start表示数组的起始位置，end表示数组的结束
位置，每次循环结束时，end都会减1，因此当start
不再小于end的时候，就代表整个数组都被遍历了，
即递归操作完成。
*/
        int temp = 0;
        for(int i = 0; i <= 8; i++){
            if(a[i]>a[i+1]){
                temp = a[i];
                a[i] = a[i+1];
                a[i+1] = temp;
            }
        }
    end --;
    mp(a,start,end);
    }
    return a;
}

int main(){
    int start = 0;
    int end = 9;
    int a[10] = {7,6,2,1,5,6,4,0,8,5};
    int *p;
    p = mp(a,start,end);

    for(int j = 0; j <=8; j++){
        cout << *(p+j) << " ";
    }
    return 0;
}

运行后输出的结果：

0 1 2 4 5 5 6 6 7
Process returned 0 (0x0)   execution time : 0.085 s
Press any key to continue.

非递归实现

双层 for 循环实现的冒泡排序（无改进）

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

int main(){
    int nums[10]={7,6,2,1,5,6,4,0,8,5};
    int temp=0;
    for(int i=0;i<=8;i++){
/*有10个数字的队列首次遍历需要比较9次，之后，
每次遍历需要比较的数字的个数都比上一次少1个。
这层循环用于确定需要遍历的队列的长度。*/
        for(int j=0;j<8-i;j++){
/*从队列第 1 个数字开始，比较到不需要比较的最后
一个数字为止，这层循环用于确定需要比较的具体的
数字。*/
            if(nums[j]>nums[j+1]){
/*如果前一个数大于后一个数，则交换两个数的位置，
把大的数字放到后面。*/
                temp = nums[j+1];
                nums[j+1]= nums[j];
                nums[j] = temp;
            }
        }
    }
    for(int z=0;z<=8;z++){
        cout<<nums[z]<<" ";
    }
    return 0;
}

上面这个程序的时间复杂度为：O(n^2^), 空间复杂度为：O(1).

双层 for 循环实现的冒泡排序（使用位置交换标志位进行改进）

我们首先对上面“双层 for 循环实现的冒泡排序（无改进）”中给出的程序做一些改变，使其能打印出每一轮排序的结果，程序如下：

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

int main(){
    int nums[10]={7,6,2,1,5,6,4,0,8,5};
    int temp=0;
    for(int i=0;i<=8;i++){
        for(int j=0;j<8-i;j++){
            if(nums[j]>nums[j+1]){
                temp = nums[j+1];
                nums[j+1]= nums[j];
                nums[j] = temp;
            }
        }
        cout<<i<<"#:"<<" ";
        for(int z=0;z<=8;z++){
        cout<<nums[z]<<" ";
    }
    cout<<endl;
    }
    return 0;
}

运行上面的程序后可以得到如下结果：

0#: 6 2 1 5 6 4 0 7 8
1#: 2 1 5 6 4 0 6 7 8
2#: 1 2 5 4 0 6 6 7 8
3#: 1 2 4 0 5 6 6 7 8
4#: 1 2 0 4 5 6 6 7 8
5#: 1 0 2 4 5 6 6 7 8
6#: 0 1 2 4 5 6 6 7 8
7#: 0 1 2 4 5 6 6 7 8
8#: 0 1 2 4 5 6 6 7 8

Process returned 0 (0x0)   execution time : 0.267 s
Press any key to continue.

通过上面的运行结果可以看出第 6 轮循环结束时排序其实已经完成，之后的 7, 8 轮排序得出的结果和第 6 轮排序得出的结果完全一致。我们可以通过在程序中添加“位置交换标志位”来避免无用的排序，即一旦发现某一轮循环结束之后没有任何一个元素的位置发生了改变，就认为此时排序已经完成，不需要进行接下来的排序。
使用“位置交换标志位”改进后的程序如下：

#include <iostream>
#include <bits/stdc++.h>
using namespace std;

int main(){
    int nums[10]={7,6,2,1,5,6,4,0,8,5};
    int temp=0;
    bool SwapFlag = true;
/*
定义位置交换标志变量
当发生位置交换时置为 true
未发生位置交换时置为 false
*/
    for(int i=0;i<=8&&SwapFlag==true;i++){
            SwapFlag=false;
/*
每开始一轮排序时都将标志位复位
(初始默认本轮不会出现交换)
*/
        for(int j=0;j<8-i;j++){
            if(nums[j]>nums[j+1]){
                SwapFlag=true;
/*
只要在一轮排序中发生了一次交换
则标志位置为 true
*/
                temp = nums[j+1];
                nums[j+1]= nums[j];
                nums[j] = temp;
            }
        }
        cout<<i<<"#:"<<" ";
        for(int z=0;z<=8;z++){
        cout<<nums[z]<<" ";
    }
    cout<<endl;
    }
    return 0;
}

输出结果如下：

0#: 6 2 1 5 6 4 0 7 8
1#: 2 1 5 6 4 0 6 7 8
2#: 1 2 5 4 0 6 6 7 8
3#: 1 2 4 0 5 6 6 7 8
4#: 1 2 0 4 5 6 6 7 8
5#: 1 0 2 4 5 6 6 7 8
6#: 0 1 2 4 5 6 6 7 8
7#: 0 1 2 4 5 6 6 7 8

Process returned 0 (0x0)   execution time : 1.070 s
Press any key to continue.

可以看到，经过改进之后，在使用相同的源代码逻辑和同一组数据的情况下，排序次数减少了 1 次。

---

更改记录：

1. 2019 年 05 月 29 日 17 时 17 分，在“冒泡排序算法的排序过程”中新增了一张演示冒泡排序的动图（图 1）并添加了有关说明。

EOF