编译apparmor_如何查看linux系统源码

❶ debian sparkr怎么配置环境变量

1. SparkR的安装配置
1.1. R与Rstudio的安装
1.1.1. R的安装
我们的工作环境都是在Ubuntu下操作的，所以只介绍Ubuntu下安装R的方法：
1）在/etc/apt/sources.list添加源
deb http://mirror.bjtu.e.cn/cran/bin/linux/ubuntu precise/，
然后更新源apt-get update；
2）通过apt-get安装：
sudo apt-get install r-base
1.1.2. Rstudio的安装
官网有详细介绍：
http://www.rstudio.com/procts/rstudio/download-server/
sudo apt-get install gdebi-core
sudo apt-get install libapparmor1 # Required only for Ubuntu, not Debian
wget http://download2.rstudio.org/rstudio-server-0.97.551-amd64.deb
sudo gdebi rstudio-server-0.97.551-amd64.deb
1.2. rjava安装
1.2.1. rJava介绍
rJava是一个R语言和Java语言的通信接口，通过底层JNI实现调用，允许在R中直接调用Java的对象和方法。
rJava还提供了Java调用R的功能，是通过JRI(Java/R Interface)实现的。JRI现在已经被嵌入到rJava的包中，我们也可以单独试用这个功能。现在rJava包，已经成为很多基于Java开发R包的基础功能组件。
正是由于rJava是底层接口，并使用JNI作为接口调用，所以效率非常高。在JRI的方案中，JVM通过内存直接加载RVM，调用过程性能几乎无损耗，因此是非常高效连接通道，是R和Java通信的首选开发包。
1.2.2. rJava安装
1）配置rJava环境
执行R CMD javareconf
root@testnode4:/home/payton# R CMD javareconf
2）启动R并安装rJava
root@testnode4:/home/payton# R
> install.packages("rJava")

1.3. SparkR的安装
1.3.1. SparkR的代码下载
从网页下载代码SparkR-pkg-master.zip https://github.com/amplab-extras/SparkR-pkg
1.3.2. SparkR的代码编译
1）解压SparkR-pkg-master.zip，然后cd SparkR-pkg-master/
2）编译的时候需要指明Hadoop版本和Spark版本
SPARK_HADOOP_VERSION=2.4.1 SPARK_VERSION=1.2.0 ./install-dev.sh
至此，单机版的SparkR已经安装完成。
1.3.3. 分布式SparkR的部署配置
1）编译成功后，会生成一个lib文件夹，进入lib文件夹，打包SparkR为SparkR.tar.gz，这个是分布式SparkR部署的关键。
2）由打包好的SparkR.tar.gz在各集群节点上安装SparkR
R CMD INSTALL SparkR.tar.gz
至此分布式SparkR搭建完成。

2. SparkR的运行
2.1. SparkR的运行机制
SparkR是AMPLab发布的一个R开发包，为Apache Spark提供了轻量的前端。SparkR提供了Spark中弹性分布式数据集（RDD）的API，用户可以在集群上通过R shell交互性的运行job。SparkR集合了Spark 和R的优势，下面的这3幅图很好的阐释了SparkR的运行机制。

2.2. 用SparkR 进行数据分析
2.2.1. SparkR基本操作
首先介绍下SparkR的基本操作：
第一步，加载SparkR包
library(SparkR)
第二步，初始化Spark context
sc <- sparkR.init(master=" spark://localhost:7077"
,sparkEnvir=list(spark.executor.memory="1g",spark.cores.max="10"))
第三步，读入数据，spark的核心是Resilient Distributed Dataset (RDD)，RDDS可以从Hadoop的InputFormats来创建（例如，HDFS文件）或通过转化其它RDDS。例如直接从HDFS读取数据为RDD的示例如下：
lines <- textFile(sc, "hdfs://sparkR_test.txt")
另外，也可以通过parallelize函数从向量或列表创建RDD，如：
rdd <- parallelize(sc, 1:10, 2)
到了这里，那么我们就可以运用RDD的动作（actions）和转换（transformations）来对RDD进行操作并产生新的RDD；也可以很容易地调用R开发包，只需要在集群上执行操作前用includePackage读取R开发包就可以了（例：includePackage(sc, Matrix)）；当然还可以把RDD转换为R语言格式的数据形式来对它进行操作。
具体可参见如下两个链接：
http://amplab-extras.github.io/SparkR-pkg/
https://github.com/amplab-extras/SparkR-pkg/wiki/SparkR-Quick-Start
那么下面我们就通过两个示例来看下 SparkR是如何运行的吧。
2.2.2. SparkR使用举例
1） Example1：word count

# 加载SparkR包
library(SparkR)
# 初始化 Spark context
sc <- sparkR.init(master="spark://集群ip:7077"
,sparkEnvir=list(spark.executor.memory="1g",spark.cores.max="10"))
# 从HDFS上读取文件
lines <- textFile(sc, "hdfs://集群ip:8020/tmp/sparkR_test.txt")
# 按分隔符拆分每一行为多个元素，这里返回一个序列
words<-flatMap(lines,function(line) {strsplit(line,"\\|")[[1]]})
# 使用 lapply 来定义对应每一个RDD元素的运算，这里返回一个（K，V)对
wordCount <-lapply(words, function(word) { list(word, 1L) })
# 对（K，V）对进行聚合计算
counts<-receByKey(wordCount,"+",2L)
# 以数组的形式，返回数据集的所有元素
output <- collect(counts)
# 按格式输出结果
for (wordcount in output) {
cat(wordcount[[1]], ": ", wordcount[[2]], "\n")
}

2） Example2：logistic regression

# 加载SparkR包
library(SparkR)
# 初始化 Spark context
sc <- sparkR.init(master="集群ip:7077",
appName='sparkr_logistic_regression',
sparkEnvir=list(spark.executor.memory='1g',
spark.cores.max="10"))
# 从hdfs上读取txt文件，该RDD由spark集群的4个分区构成
input_rdd <- textFile(sc,
"hdfs://集群ip:8020/user/payton/german.data-numeric.txt",
minSplits=4)
# 解析每个RDD元素的文本（在每个分区上并行）
dataset_rdd <- lapplyPartition(input_rdd, function(part) {
part <- lapply(part, function(x) unlist(strsplit(x, '\\s')))
part <- lapply(part, function(x) as.numeric(x[x != '']))
part
})
# 我们需要把数据集dataset_rdd分割为训练集（train）和测试集（test）两部分，这里
# ptest为测试集的样本比例，如取ptest=0.2，即取dataset_rdd的20%样本数作为测试
# 集，80%的样本数作为训练集
split_dataset <- function(rdd, ptest) {
#以输入样本数ptest比例创建测试集RDD
data_test_rdd <- lapplyPartition(rdd, function(part) {
part_test <- part[1:(length(part)*ptest)]
part_test
})
# 用剩下的样本数创建训练集RDD
data_train_rdd <- lapplyPartition(rdd, function(part) {
part_train <- part[((length(part)*ptest)+1):length(part)]
part_train
})
# 返回测试集RDD和训练集RDD的列表
list(data_test_rdd, data_train_rdd)
}
# 接下来我们需要转化数据集为R语言的矩阵形式，并增加一列数字为1的截距项，
# 将输出项y标准化为0/1的形式
get_matrix_rdd <- function(rdd) {
matrix_rdd <- lapplyPartition(rdd, function(part) {
m <- matrix(data=unlist(part, F, F), ncol=25, byrow=T)
m <- cbind(1, m)
m[,ncol(m)] <- m[,ncol(m)]-1
m
})
matrix_rdd
}
# 由于该训练集中y的值为1与0的样本数比值为7:3，所以我们需要平衡1和0的样本
# 数，使它们的样本数一致
balance_matrix_rdd <- function(matrix_rdd) {
balanced_matrix_rdd <- lapplyPartition(matrix_rdd, function(part) {
y <- part[,26]
index <- sample(which(y==0),length(which(y==1)))
index <- c(index, which(y==1))
part <- part[index,]
part
})
balanced_matrix_rdd
}
# 分割数据集为训练集和测试集
dataset <- split_dataset(dataset_rdd, 0.2)
# 创建测试集RDD
matrix_test_rdd <- get_matrix_rdd(dataset[[1]])
# 创建训练集RDD
matrix_train_rdd <- balance_matrix_rdd(get_matrix_rdd(dataset[[2]]))
# 将训练集RDD和测试集RDD放入spark分布式集群内存中
cache(matrix_test_rdd)
cache(matrix_train_rdd)
# 初始化向量theta
theta<- runif(n=25, min = -1, max = 1)
# logistic函数
hypot <- function(z) {
1/(1+exp(-z))
}
# 损失函数的梯度计算
gCost <- function(t,X,y) {
1/nrow(X)*(t(X)%*%(hypot(X%*%t)-y))
# 定义训练函数
train <- function(theta, rdd) {
# 计算梯度
gradient_rdd <- lapplyPartition(rdd, function(part) {
X <- part[,1:25]
y <- part[,26]
p_gradient <- gCost(theta,X,y)
list(list(1, p_gradient))
})
agg_gradient_rdd <- receByKey(gradient_rdd, '+', 1L)
# 一次迭代聚合输出
collect(agg_gradient_rdd)[[1]][[2]]
}
# 由梯度下降算法优化损失函数
# alpha ：学习速率
# steps ：迭代次数
# tol ：收敛精度
alpha <- 0.1
tol <- 1e-4
step <- 1
while(T) {
cat("step: ",step,"\n")
p_gradient <- train(theta, matrix_train_rdd)
theta <- theta-alpha*p_gradient
gradient <- train(theta, matrix_train_rdd)
if(abs(norm(gradient,type="F")-norm(p_gradient,type="F"))<=tol) break
step <- step+1
}
# 用训练好的模型预测测试集信贷评测结果（“good”或“bad”），并计算预测正确率
test <- lapplyPartition(matrix_test_rdd, function(part) {
X <- part[,1:25]
y <- part[,26]
y_pred <- hypot(X%*%theta)
result <- xor(as.vector(round(y_pred)),as.vector(y))
})
result<-unlist(collect(test))
corrects = length(result[result==F])
wrongs = length(result[result==T])
cat("\ncorrects: ",corrects,"\n")
cat("wrongs: ",wrongs,"\n")
cat("accuracy: ",corrects/length(y_pred),"\n")

❷ 如何在"特殊"的网络环境下编译 Docker

❸ 想实现一个linux内核安全功能模块的技术思路是怎样的

参考网站：http://www.hu.com/question/21637060
用户在执行系统调用时，先通过原有的内核接口依次执行功能性的错误检查，接着进行传统的DAC检查，并在即将访问内核的内部对象之前，通过LSM钩子函数调用LSM。LSM再调用具体的访问控制策略来决定访问的合法性。访问控制整体构架：
LSM框架下访问决策模块包括selinux，smack，tomoyo，yama，apparmor.
每个决策模块都是通过各自的XXX_init函数调用register_security（）函数，注册到LSM框架的模块被加载成功后，就可以进行访问控制操作。如果此时还有一个安全模块要使用register_security()函数进行加载，则会出现错误，直到使用框架注销后，下一个模块才可以载入。

Linux安全模块（LSM）提供了两类对安全钩子函数的调用：一类管理内核对象的安全域，另一类仲裁对这些内核对象的访问。对安全钩子函数的调用通过钩子来实现，钩子是全局表security_ops中的函数指针，这个全局表的类型是security_operations结构，这个结构定义在include/linux/security.h这个头文件中。
通过对security代码进行一番简单的分析，LSM启动过程流图：

security_initcall只能调用selinux_init，smack_init ，tomoyo_init ， yama_init 和apparmor_init中的一个，因为内核不允许多种安全机制同时一起工作。一旦一个安全模块被加载，就成为系统的安全策略决策中心，而不会被后面的register_security()函数覆盖，直到这个安全模块被使用unregister_security()函数向框架注销。

因此LSM框架下只能开启一种安全机制，smack编译进Linux内核的配置和要求：

（1）要求smack和selinux不能够同时运行，不能同时存在于同一个运行中的内核；
查看内核是否开启以下的功能（如果没有则需要开启）：

CONFIG_NETLABEL=y
CONFIG_SECURITY=y
CONFIG_SECURITY_NETWORK=y
CONFIG_SECURITY_SMACK=y
CONFIG_SECURITY_SELINUX should not be
set

步骤：

make menuconfig
make moles_install
make install
查看/proc/filesystems
可以看到smackfs，说明smack已经编进内核

执行如下的命令：
mkdir -p /smack
在文件/etc/fstab添加下面的一行
smackfs /smack smackfs defaults 0 0
然后执行下面的命令：
mount –a

然后就体验一下它的功能了：
1. 比如在用户test的home目录下(/home/test)，新建文件夹 mkdir testdir
cd testdir/
touch testfile
2. 给新建的testfile 打上TheOther标签
setfattr
--name=security.SMACK64 --value=TheOther testfile
查看其标签
getfattr
--only-values -n security.SMACK64 -e text testfile
可以看到标签TheOther

3. echo TheOne
2>/dev/null > /proc/self/attr/current，当前执行的进程默认都会被打为/proc/self/attr/current下的标签
4.配置策略echo -n "TheOne TheOther r---"> /sma ck/load
因为当前进程只要是没有特殊配置过的都被打为TheOne，所以当转换到普通用户test下，cat testfile是可读的
5.现在我将当前进程打为NotTheOne ，echo NotTheOne 2>/dev/null >
/proc/self/attr/current
当转换到普通用户test下，cat testfile则变成不可读的了
6．如果你想单独对某个进程打标签，而不是对当前进程打，就
attr -s security.SMACK64 -V TheOne /bin/cat
此时cat被标为TheOne，根据策略可以看出，当转换到普通用户test下，cat testfile是可读的
若attr -s
security.SMACK64 –V Not TheOne /bin/cat
根据策略可以看出，当转换到普通用户test下，cat testfile是不可读的
（需要说明的一点是，当cat本身被标上标签和/proc/self/attr/current打入标签共存时，cat本身的标签生效，而/proc/self/attr/current打入标签没有生效）

❹ 我已经完成了ubuntu10.10的内核编译，现在是2.6.33.20的内核，为什么还是不能安装selinux

没遇到过。可能是软件包的依赖关系问题，你原来的内核版本比这个高吗？我不确定内核是否影响软件包依赖。我只能说，试试更新管理器里，更新软件包，注意不要选择内核包。

❺ 想实现一个linux内核安全功能模块的技术思路是怎样的

❻ 如何查看linux系统源码

一般在Linux系统中的/usr/src/linux*.*.*（*.*.*代表的是内核版本，如2.4.23）目录下就是内核源代码（如果没有类似目录，是因为还没安装内核代码）。另外还可从互连网上免费下载。注意，不要总到http://www.kernel.org/去下载，最好使用它的镜像站点下载。请在http://www.kernel.org/mirrors/里找一个合适的下载点，再到pub/linux/kernel/v2.6/目录下去下载2.4.23内核。
代码目录结构
在阅读源码之前，还应知道Linux内核源码的整体分布情况。现代的操作系统一般由进程管理、内存管理、文件系统、驱动程序和网络等组成。Linux内核源码的各个目录大致与此相对应，其组成如下（假设相对于Linux-2.4.23目录）：
1.arch目录包括了所有和体系结构相关的核心代码。它下面的每一个子目录都代表一种Linux支持的体系结构，例如i386就是Intel CPU及与之相兼容体系结构的子目录。PC机一般都基于此目录。
2.include目录包括编译核心所需要的大部分头文件，例如与平台无关的头文件在include/linux子目录下。
3.init目录包含核心的初始化代码（不是系统的引导代码），有main.c和Version.c两个文件。这是研究核心如何工作的好起点。
4.mm目录包含了所有的内存管理代码。与具体硬件体系结构相关的内存管理代码位于arch/*/mm目录下。
5.drivers目录中是系统中所有的设备驱动程序。它又进一步划分成几类设备驱动，每一种有对应的子目录，如声卡的驱动对应于drivers/sound。
6.ipc目录包含了核心进程间的通信代码。
7.moles目录存放了已建好的、可动态加载的模块。
8.fs目录存放Linux支持的文件系统代码。不同的文件系统有不同的子目录对应，如ext3文件系统对应的就是ext3子目录。
Kernel内核管理的核心代码放在这里。同时与处理器结构相关代码都放在arch/*/kernel目录下。
9.net目录里是核心的网络部分代码，其每个子目录对应于网络的一个方面。
10.lib目录包含了核心的库代码，不过与处理器结构相关的库代码被放在arch/*/lib/目录下。
11.scripts目录包含用于配置核心的脚本文件。
12.documentation目录下是一些文档，是对每个目录作用的具体说明。
一般在每个目录下都有一个.depend文件和一个Makefile文件。这两个文件都是编译时使用的辅助文件。仔细阅读这两个文件对弄清各个文件之间的联系和依托关系很有帮助。另外有的目录下还有Readme文件，它是对该目录下文件的一些说明，同样有利于对内核源码的理解。
在阅读方法或顺序上，有纵向与横向之分。所谓纵向就是顺着程序的执行顺序逐步进行；所谓横向，就是按模块进行。它们经常结合在一起进行。对于Linux启动的代码可顺着Linux的启动顺序一步步来阅读；对于像内存管理部分，可以单独拿出来进行阅读分析。实际上这是一个反复的过程，不可能读一遍就理解。

❼ 如何在"特殊"的网络环境下编译 Docker

由于 Docker 编译需要依赖于 Docker Daemon ，所以只能在 64 位的 Linux 环境下先安装 Docker 程序，再从 Github 上克隆 Docker 的代码进行编译。
在 Docker 的目录下执行 make 命令将默认执行 Makefile 中 make binary 指令进行编译。
?

default: binary

all: build
$(DOCKER_RUN_DOCKER) hack/make.sh

binary: build
$(DOCKER_RUN_DOCKER) hack/make.sh binary

cross: build
$(DOCKER_RUN_DOCKER) hack/make.sh binary cross

从以上的 Makefile 可以看出，执行 make、make binary、make all 或 make cross 都可以得到可运行的 Docker 程序。
在 Mac OS 环境下使用 brew 的命令安装 Docker ，只能得到一个 docker client 的二进制程序，如果以 daemon 的方式运行，会得到 ‘This is a client-only binary - running the Docker daemon is not supported.’ 的错误提示信息。
方法 1.
使用 VirtualBox 或者 VMWare Workstation 安装一个 Linux 的虚拟机。宿主机使用 VPN 等方案使网络“正常”访问各种“服务”，虚拟机网卡使用 NAT 模式。在 Linux 虚拟机内使用 make 进行编译 Docker 不会有任何网络问题。只是编译速度受限于 VPN 等网络解决方案，有可能等待时间很长。
方法 2.
Docker 每次发布新版本，都会在 docker-dev 的镜像仓库发布一个新的标签，这个镜像仓库包含了编译 Docker 镜像所依赖的所有环境，只需替换 Docker 代码目录下的 Dockerfile 即可实现编译 Docker 。
?

FROM docker.cn/docker/docker-dev:v1.2.0
VOLUME /var/lib/docker
WORKDIR /go/src/github.com/docker/docker
ENV DOCKER_BUILDTAGS apparmor selinux
ENTRYPOINT [“hack/dind”]
COPY . /go/src/github.com/docker/docker

Dockerfile 中只保留必要的步骤就可以实现编译了。
方法 3.
对 Docker 代码中的 Docker 进行彻底的改造，用国内的各种镜像替换其中不能在“正常”网络条件下访问的镜像，使得代码能够快速编译通过。
?

FROM docker.cn/docker/ubuntu:14.04.1
MAINTAINER Meaglith Ma <[email protected]> (@genedna)

RUN echo "deb http://mirrors.aliyun.com/ubuntu trusty main universe" > /etc/apt/sources.list && echo "deb-src http://mirrors.aliyun.com/ubuntu/ trusty main restricted" >> /etc/apt/sources.list && echo "deb http://mirrors.aliyun.com/ubuntu/ trusty-updates main restricted" >> /etc/apt/sources.list && echo "deb-src http://mirrors.aliyun.com/ubuntu/ trusty-updates main restricted" >> /etc/apt/sources.list && echo "deb http://mirrors.aliyun.com/ubuntu/ trusty universe" >> /etc/apt/sources.list && echo "deb-src http://mirrors.aliyun.com/ubuntu/ trusty universe" >> /etc/apt/sources.list && echo "deb http://mirrors.aliyun.com/ubuntu/ trusty-updates universe" >> /etc/apt/sources.list && echo "deb-src http://mirrors.aliyun.com/ubuntu/ trusty-updates universe" >> /etc/apt/sources.list && echo "deb http://mirrors.aliyun.com/ubuntu/ trusty-security main restricted" >> /etc/apt/sources.list && echo "deb-src http://mirrors.aliyun.com/ubuntu/ trusty-security main restricted" >> /etc/apt/sources.list && echo "deb http://mirrors.aliyun.com/ubuntu/ trusty-security universe" >> /etc/apt/sources.list && echo "deb-src http://mirrors.aliyun.com/ubuntu/ trusty-security universe" >> /etc/apt/sources.list

RUN apt-get update && apt-get install -y \
aufs-tools \
automake \
btrfs-tools \
build-essential \
curl \
dpkg-sig \
git \
iptables \
libapparmor-dev \
libcap-dev \
libsqlite3-dev \
lxc=1.0* \
mercurial \
parallel \
reprepro \
ruby1.9.1 \
ruby1.9.1-dev \
s3cmd=1.1.0* \
unzip \
--no-install-recommends

RUN git clone --no-checkout https://coding.net/genedna/lvm2.git /usr/local/lvm2 && cd /usr/local/lvm2 && git checkout -q v2_02_103

RUN cd /usr/local/lvm2 && ./configure --enable-static_link && make device-mapper && make install_device-mapper

RUN curl -sSL http://docker-cn.qiniudn.com/go1.3.1.src.tar.gz | tar -v -C /usr/local -xz
ENV PATH /usr/local/go/bin:$PATH
ENV GOPATH /go:/go/src/github.com/docker/docker/vendor
ENV PATH /go/bin:$PATH
RUN cd /usr/local/go/src && ./make.bash --no-clean 2>&1

ENV DOCKER_CROSSPLATFORMS \
linux/386 linux/arm \
darwin/amd64 darwin/386 \
freebsd/amd64 freebsd/386 freebsd/arm
ENV GOARM 5
RUN cd /usr/local/go/src && bash -xc 'for platform in $DOCKER_CROSSPLATFORMS; do GOOS=${platform%/*} GOARCH=${platform##*/} ./make.bash --no-clean 2>&1; done'

RUN mkdir -p /go/src/github.com/gpmgo \
&& cd /go/src/github.com/gpmgo \
&& curl -o gopm.zip http://gopm.io/api/v1/download?pkgname=github.com/gpmgo/gopm\&revision=dev --location \
&& unzip gopm.zip \
&& mv $(ls | grep "gopm-") gopm \
&& rm gopm.zip \
&& cd gopm \
&& go install

RUN gopm bin -v code.google.com/p/go.tools/cmd/cover

RUN gem sources --remove https://rubygems.org/ \
&& gem sources -a https://ruby.taobao.org/ \
&& gem install --no-rdoc --no-ri fpm --version 1.0.2

RUN gopm bin -v -d /go/bin github.com/cpuguy83/go-md2man@tag:v1

RUN git clone -b buildroot-2014.02 https://github.com/jpetazzo/docker-busybox.git /docker-busybox

RUN /bin/echo -e '[default]\naccess_key=$AWS_ACCESS_KEY\nsecret_key=$AWS_SECRET_KEY' > /.s3cfg

RUN git config --global user.email '[email protected]'

RUN groupadd -r docker
RUN useradd --create-home --gid docker unprivilegeser

VOLUME /var/lib/docker
WORKDIR /go/src/github.com/docker/docker
ENV DOCKER_BUILDTAGS apparmor selinux

ENTRYPOINT ["hack/dind"]

COPY . /go/src/github.com/docker/docker

以上的命令把 Ubuntu 镜像中的源替换为国内速度较快的阿里源；把 lvm2 镜像到国内的 Git 托管服务 coding.net；从七牛云存储保存的 Golang 源码进行获取和编译；使用 gopm 下载编译所需要的 Library ；最后把其中 gem 源切换到淘宝。至此，可以在“特殊”的网络条件下快速编译 Docker 。

❽ 为什么说Linux比Windows安全

一：病毒
1)Windows下都是administrator用户登录，病毒可以自由感染系统任何文件;ubuntu下普通用户不能修改系统文件。
2)Windows用户很多，研究的人也多，病毒，木马数量也很多，被攻击的数量也很多，攻击Windows终端用户有很多商业利益，如偷qq号，偷银行交易密码等等，有利益驱动研究的人也越多，“成果”也就越多；linux当前还没有普及所以病毒很少。
二：木马
同上
三：流氓软件
同上
四：常见攻击和入侵
同上，但需要补充一下，攻击者通常攻击两个方向：
a)终端用户，偷取个人信息
b)服务器，一次性获取巨额利益，比如攻击银行IBM AIX / HP-UX 等等大机，目前ubuntu两者都不算，所以很安全
五：系统设计架构上的差异
1. Win2k没有栈保护，很容易溢出/Win2k malloc攻击也没有加强;WinXP稍有加强，但相对还是容易；Win2003加强了很多，很难攻击了，现在的芯片也都有栈不可执行保护了，XP sp2以后和2003都利用了此特性，这将很难实施溢出攻击
2. Linux kernel 2.6以后的版本很多默认开启了栈保护功能，而起2.4 kernel很久前就有非官方的PAX内核补丁，加强了对抗溢出攻击，可以说早就达到了2003的标准，kernel 2.6现在的版本都内置了此功能
3. 大的服务器芯片+OS: SPARC+Solaric / PowerPC + AIX / PA + HP-UX 等在9x年就有了芯片+内核的栈不可执行保护机制
4.linux文件系统本身的特性，没个文件夹、文件都有所有者、所有组、其它用户，而且对这三者可以分别设置读、写、执行的权限，而且在权限的分配和管理上也下了很大的功夫，这样在以普通用户登陆的情况下，很难危及到关键的系统文件的安全。这些都是windows的文件系统所没有的特性。Unix权限机制的确是对Windows的先天优势，但NT4的内核是VMS起来的，也是Unix的一个分支，安全机制真正用起来也不弱。
关键还是它定位为主要是单用户使用，定位不同。
六：开源
当黑客与工程师同时发现系统的漏洞时，windows封闭源，UBUNTU开源，黑客只是利用漏洞，而工程师在开源情况下可以自己修复漏洞，而在封闭源情下只能等待补丁，UBUNTU公开源有世界各地的爱好者为系统修复，而windows只能等待微软修复。
七：关于Ubuntu安全性的其它建议
1. 关闭所有对外服务，如ssh
2. 开启iptables，只让需要访问你的人能连上你
当黑客与工程师同时发现系统的漏洞时，windows封闭源，UBUNTU开源，黑客只是利用漏洞，而工程师在开源情况下可以自己修复漏洞，而在封闭源情下只能等待补丁，UBUNTU公开源有世界各地的爱好者为系统修复，而windows只能等待微软修复
大多数黑客（真正的黑客，不是拿着木马专搞破坏的那种）致力于对操作系统的研究的同时，不遗余力地为操作系统修补漏洞，尽管这些人往往对Windows系统没有好感，但他们也不吝于为Win做一些事情，当然他们干的更多的是为Unix/linux修补漏洞，所以往往Linux系统的漏洞一经发现，补丁也随之产生；至于Windows──什么事情都等工程师的话，龟波气功都出来了，更别说冲击波、震荡波啦。
3.真正直接获取利益就是攻击大量的个人用户和攻击商用大机获取数据，前者比较容易实施，后者你看金融都用IBM AIX/HP-UX ...，都放在内网，想当难攻击。攻击在公网的WEB服务器，邮件服务器很难，因为他们只开放了1个对外服务，这时候攻击的是这个服务，如apache，难度很大，而且管理员不会在上面装什么软件，攻击途径也少多了，所以现在的攻击都转向了攻击客户端，而客户端自然要大面积撒网，所以攻击对象就转向了windows用户群了。

❾ 如何在Ubuntu上检查一个软件包是否安装

如何在Ubuntu上检查一个软件包是否安装（引用Believe41o的专业答案）：
在Ubuntu上检查一个软件包是否安装的方法：
如果正在管理Debian或者Ubuntu服务器，也许会经常使用dpkg 或者 apt-get命令。这两个命令用来安装、卸载和更新包。在这里看下如何在基于DEB的系统下检查是否安装了一个包。
一、要检查特定的包，比如firefox是否安装了，使用这个命令：
dpkg -s firefox

示例输出：
Package: firefox Status:
install ok installed Priority: optional
Section: web
Installed-Size: 93339
Maintainer: Ubuntu Mozilla Team <[email protected]> Architecture: amd64
Version: 35.0+build3-0ubuntu0.14.04.2
Replaces: kubuntu-firefox-installer
Provides: gnome-www-browser, iceweasel, www-browser
Depends: lsb-release, libasound2 (>= 1.0.16), libatk1.0-0 (>= 1.12.4), libc6 (>= 2.17), libcairo2 (>= 1.2.4), libdbus-1-3 (>= 1.0.2), libdbus-glib-1-2 (>= 0.78), libfontconfig1 (>= 2.9.0), libfreetype6 (>= 2.2.1), libgcc1 (>= 1:4.1.1), libgdk-pixbuf2.0-0 (>= 2.22.0), libglib2.0-0 (>= 2.37.3), libgtk2.0-0 (>= 2.24.0), libpango-1.0-0 (>= 1.22.0), libpangocairo-1.0-0 (>= 1.14.0), libstartup-notification0 (>= 0.8), libstdc++6 (>= 4.6), libx11-6, libxcomposite1 (>= 1:0.3-1), libxdamage1 (>= 1:1.1), libxext6, libxfixes3, libxrender1, libxt6
Recommends: xul-ext-ubufox, libcanberra0, libdbusmenu-glib4, libdbusmenu-gtk4
Suggests: ttf-lyx
Conffiles:
/etc/firefox/syspref.js /etc/apport/blacklist.d/firefox /etc/apport/native-origins.d/firefox /etc/apparmor.d/usr.bin.firefox
Description: Safe and easy web browser from Mozilla
Firefox delivers safe, easy web browsing. A familiar user interface,
enhanced security features including protection from online identity theft,
and integrated search let you get the most out of the web.
Xul-Appid: {ec8030f7-c20a-464f-9b0e-13a3a9e97384}

如上所见，firefox已经安装了。

二、同样可以使用dpkg-query 命令。这个命令会有一个更好的输出，当然可以用通配符。
dpkg-query -l firefox

示例输出：
Desired=Unknown/Install/Remove/Purge/Hold| Status=Not/Inst/Conf-files/Unpacked/halF-conf/Half-inst/trig-aWait/Trig-pend|/ Err?=(none)/Reinst-required (Status,Err: uppercase=bad)||/ Name
Version
Architecture
Description+++-====================================-=======================-=======================-=============================================================================
ii firefox 35.0+build3-0ubuntu0.14 amd64
Safe and easy web browser from Mozilla

三、要列出系统中安装的所有包，输入下面的命令：
dpkg --get-selections

示例输出：
abiword
installabiword-common
installaccountsservice
installacl
installadser
installalsa-base
installalsa-utils
installanacron
installapp-install-data
installapparmor
install...zeitgeist
installzeitgeist-core
installzeitgeist-datahub
installzenity
installzenity-common
installzip
installzlib1g:amd64
installzlib1g:i386
install

上面的输出可能会非常长，这依赖于系统已安装的包。

四、同样可以通过grep来过滤割到更精确的包。比如想要使用dpkg命令查看系统中安装的gcc包：
dpkg --get-selections | grep gcc

示例输出：
gcc
installgcc-4.8
installgcc-4.8-base:amd64
installgcc-4.8-base:i386
installgcc-4.9-base:amd64
installgcc-4.9-base:i386
installlibgcc-4.8-dev:amd64
installlibgcc1:amd64
installlibgcc1:i386
install

五、此外，可以使用“-L”参数来找出包中文件的位置。
dpkg -L gcc-4.8

示例输出：
/.
/usr
/usr/share
/usr/share/doc
/usr/share/doc/gcc-4.8-base
/usr/share/doc/gcc-4.8-base/README.Bugs
/usr/share/doc/gcc-4.8-base/NEWS.html
/usr/share/doc/gcc-4.8-base/quadmath
/usr/share/doc/gcc-4.8-base/quadmath/changelog.gz
/usr/share/doc/gcc-4.8-base/gcc...
/usr/bin/x86_64-linux-gnu-gcc-4.8
/usr/bin/x86_64-linux-gnu-gcc-ar-4.8
/usr/bin/x86_64-linux-gnu-gcov-4.8

❿ 如何在"特殊"的网络环境下编译 Docker

方法 1.
使用 VirtualBox 或者 VMWare Workstation 安装一个 Linux 的虚拟机。宿主机使用 VPN 等方案使网络“正常”访问各种“服务”，虚拟机网卡使用 NAT 模式。在 Linux 虚拟机内使用 make 进行编译 Docker 不会有任何网络问题。只是编译速度受限于 VPN 等网络解决方案，有可能等待时间很长。
方法 2.
Docker 每次发布新版本，都会在 docker-dev 的镜像仓库发布一个新的标签，这个镜像仓库包含了编译 Docker 镜像所依赖的所有环境，只需替换 Docker 代码目录下的 Dockerfile 即可实现编译 Docker 。
FROM docker.cn/docker/docker-dev:v1.2.0
VOLUME /var/lib/docker
WORKDIR /go/src/github.com/docker/docker
ENV DOCKER_BUILDTAGS apparmor selinux
ENTRYPOINT [“hack/dind”]
COPY . /go/src/github.com/docker/docker

Dockerfile 中只保留必要的步骤就可以实现编译了。

导航:首页 > 源码编译 > 编译apparmor

编译apparmor

与编译apparmor相关的资料