精华内容
下载资源
问答
  • chroot 命令帮助信息与几个相关问题
    2020-10-24 13:44:41

    chroot 命令的帮助信息

    chroot 命令的详细帮助信息通过执行如下命令来查看:

    info coreutils 'chroot invocation'
    

    chroot 帮助信息的翻译

    chroot : 使用一个不同的 root 目录运行程序

    chroot 使用指定的 root 目录运行程序。在许多系统上面,只有 root 用户能够使用这个功能。命令参数如下:

         chroot OPTION NEWROOT [COMMAND [ARGS]...]
         chroot OPTION
    

    通常,文件名从根目录结构开始搜索。 chroot 将这个根目录切换为 NEWROOT 目录(必须存在)然后使用可选的 ARGS 参数运行 COMMAND 中指定的命令。如果用户没有指定 COMMAND,默认将会使用 SHELL 环境变量的值,如果该环境变量未设定则使用 /bin/sh 程序并设定 -i 选项来执行。

    COMMAND 不能是一个特殊的内置函数。

    chroot 程序接受下面的参数。

    1. –userspec=USER[:GROUP]
      默认情况下,COMMAND 将会使用与调用程序相同的权限运行。使用这个选项能够以一个不同的用户、不同的组、不同的用户与不同的组来运行。

    2. –groups=GROUPS
      使用这个选项指定新的进程使用的可选组。GROUPS 列表中的每一项(名字或数字 id)必须使用逗号分隔。

    3. –skip-chdir
      使用这个选项在切换 root 目录为 NEWROOT 的时候不切换当前的工作目录为根目录。这个选项在只在新的根目录与老的根目录一致时才能够生效,因此在与 ‘–groups’ 和 '–userspec ’ 选项一起使用时能够被用来保持旧的工作目录。

    这里有一些帮助用户解决使用 chroot 遇到的常见问题的技巧。首先以一个简单的示例开始,让 COMMAND 指向一个静态链接的程序。如果你想要使用一个动态链接的程序,你必须在你要切换的新的 root 目录中将程序执行依赖的动态库放在正确的位置中。

    例如,如果你创建了一个静态链接的 ls 可执行程序,并将它放在 /tmp/empty 目录中,你可以使用 root 运行这个命令:

         $ chroot /tmp/empty /ls -Rl /
    

    然后你将会看到像下面一样的输出信息:

         /:
         total 1023
         -rwxr-xr-x 1 0 0 1041745 Aug 16 11:17 ls
    

    如果你想使用一个动态链接的程序,例如 bash,你首先要运行 ldd bash 来查看它依赖了那些动态库。然后拷贝实际的可执行程序,并且拷贝 ldd 输出的依赖文件到你打算使用的新的 root 目录中的正确位置中。最后,如果可执行程序还依赖了其它文件(例如数据、状态、设备文件),也将它们拷贝到正确的位置中。

    错误状态:

     125 chroot 自身执行失败
     126 COMMAND 被找到但是不能被执行
     127 COMMAND 不能找到
    其它 COMMAND 的退出状态
    

    备注:

    然而,一些系统(例如 FreeBSD)能够被配置为允许特定的普通用户使用 chroot 系统调用,因此一些普通用户也能够运行 chroot 程序。同样在 Cygwin 环境中,任何人都能够运行 chroot 命令,因为缺少 MS-Windows 的支持这个 chroot 是非特权函数。

    如何让外部目录在 chroot 环境中可见?

    为了达到这样的效果,我们可以在宿主机上挂载设备到 chroot 切换的根目录内的新目录中,从宿主机上挂载设备到 chroot 使用的新的根目录内,chroot 运行的程序就能够访问到宿主机上的目录了。

    如何在 chroot 环境中调用外部脚本?

    可以在 chroot 环境中通过 ssh 来实现,如果外部脚本是图形化程序,可能还需要设定 DISPLAY 变量的值。

    如何让外部环境访问到 chroot 环境内创建的文件?

    chroot 只限定当前进程到某个目录中,并不是让某个目录只能被某个进程所使用、直接对外部环境隐藏目录。chroot 前后宿主机仍旧能够访问到 chroot 的新目录,这意味着在 chroot 环境内创建的文件直接可以被外界访问。

    参考链接

    https://stackoverflow.com/questions/3171964/call-external-script-within-chroot-environment

    更多相关内容
  • chroot命令 改变根目录

    2021-01-09 20:11:52
    chroot命令用于改变根目录。chroot(change root)命令把根目录换成指定的目的目录。 语法格式:chroot [参数] 常用参数: –help  在线帮助 –version 显示版本信息 参考实例 改变根目录: [root@...
  • linux chroot命令详解

    2021-01-11 04:09:56
    为什么要使用 chroot 命令 增加了系统的安全性,限制了用户的权力: 在经过 chroot 之后,在新根下将访问不到旧系统的根目录结构和文件,这样就增强了系统的安全性。一般会在用户登录前应用 chroot,把用户的访问...
  • 这几天心血来潮去玩termux,结果最难受的是突然发现termux-chroot命令无法使用,经过在茫茫网络中的搜索,终于在GitHub上找到了解决方案。 参考这个问题,大佬们的答案 https://github.com/termux/proot/issues/87 ...
  • Linux chroot命令 Linux chroot命令用于改变根目录。 chroot(change root)命令把根目录换成指定的目的目录。 、 语法chroot [--help][--version][目的目录][执行指令...] 参数说明: –help 在线帮助。 –version ...
  • chroot命令

    万次阅读 2016-09-15 13:47:38
    转载: 理解 chroot什么是 chroot chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以 /,即是以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以指定的...

    转载: 理解 chroot

    什么是 chroot
    chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以 /,即是以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以指定的位置作为 / 位置。

    图 1. Linux 系统的目录结构
    这里写图片描述

    为何使用 chroot
    在经过 chroot 之后,系统读取到的目录和文件将不在是旧系统根下的而是新根下(即被指定的新的位置)的目录结构和文件,因此它带来的好处大致有以下3个:

    A. 增加了系统的安全性,限制了用户的权力;
    在经过 chroot 之后,在新根下将访问不到旧系统的根目录结构和文件,这样就增强了系统的安全性。这个一般是在登录 (login) 前使用 chroot,以此达到用户不能访问一些特定的文件。

    B. 建立一个与原系统隔离的系统目录结构,方便用户的开发;
    使用 chroot 后,系统读取的是新根下的目录和文件,这是一个与原系统根下文件不相关的目录结构。在这个新的环境中,可以用来测试软件的静态编译以及一些与系统不相关的独立开发。

    C. 切换系统的根目录位置,引导 Linux 系统启动以及急救系统等。
    chroot 的作用就是切换系统的根位置,而这个作用最为明显的是在系统初始引导磁盘的处理过程中使用,从初始 RAM 磁盘 (initrd) 切换系统的根位置并执行真正的 init。另外,当系统出现一些问题时,我们也可以使用 chroot 来切换到一个临时的系统。

    chroot 的使用
    为了更好的理解 chroot 发挥的作用,我们将尝试指定一个特定的位置进行根目录切换。但是由于在经过 chroot 之后,系统读取到的 bin/ 等与系统相关目录将不再是旧系统根目录下的,而是切换后新根下的目录结构和文件,因此我们有必要准备一些目录结构以及必要的文件。

    清单 1. 准备切换的目录结构

    $ pwd
    /home/wstone/Build/work
    $ tree .
    .
    |-- bin
    | |-- ash -> busybox
    | |-- bash
    | `-- busybox
    |-- etc
    `-- newhome

    这里使用了静态编译后的 busybox 来提供必要的命令,使用静态编译仅是为了避免动态库文件的拷贝。当然我们也可以拷贝旧系统的下的命令到新的目录结构中使用,但是那些命令通常是动态编译的,这就意味着我们不得不拷贝相关的动态库文件到相应的目录结构中。同时这里的 bash 也非真正的 Bourne Again shell,而是一个执行 ash 的 shell 脚本。在清单 2中,展示了位于旧系统中的 chroot 命令的使用。需要注意的是在使用 chroot 时,要求拥有相关的操作权限。

    在/home/wstone/Build/work 目录下建立一个文件,名为”bash”,内容就两行如下:

    #!/bin/ash
    ash

    然后给与这个”bash”文件可执行权利
    chmod +x ./bin/bash

    这个脚本的第一句表示解析该脚本的解释器( interpreter)所在位置。chroot缺省执行/bin/bash命令。为了要在新的chroot环境下使用ash,所以建立/bin/bash这个用来执行ash的文件。也可以显示的指出要执行的命令,比如要执行ash

    $ pwd
    /home/wstone/Build/work
    $chroot . ./bin/ash
    #pwd
    /

    清单 2. 位于系统中的 chroot 的使用

    $ pwd
    /home/wstone/Build/work
    
    # chroot .
    # pwd
    /
    
    # ls
    ash: ls: not found
    
    # busybox ls
    bin      etc      newhome
    
    3 directories, 3 files

    我们可以看到当前路径(/home/wstone/Build/work/),在经过 chroot 后转变成了 / 目录,同时从新根下读取了与系统相关的目录结构。使用 ls 命令失败是由于我们创建的测试目录结构中并没有包含命令 ls,但是我们成功的使用了 busybox 中的 ls。以上看到的只是 chroot 的一种使用方式,其实标准的 chroot (Coreutils - GNU core utilities 提供的 chroot)使用方式有2种:

    清单 3. 标准 chroot 的2种使用方式

    [1] chroot NEWROOT [COMMAND...]
    [2] chroot OPTION

    刚才我们使用的是方式[2]。这将在没有给定环境时,默认执行 /bin/sh,但是当给定环境后,将运行 ${SHELL} –i,即与环境相同的可交互的 shell。我们的目录结构中并没有包含sh,显然清单 2中的 chroot 运行了 ${SHELL} –i。当然我们也可以在进行切换时指定需要的命令,即使用方式[1]。

    清单 4. chroot 另一种方式的使用

    # chroot . /bin/ash
    # 

    在清单 4 中,尝试了在经过 chroot 后,执行新目录结构下的 ash shell。不得不说的是,如果新根下的目录结构和文件准备的够充分,那么一个新的简单的 Linux 系统就可以使用了。其实更为常见的是在初始 RAM 磁盘 (initrd)中使用 chroot,以此来执行系统的 init。清单 5 中,展示的是在 Linux 2.4 内核 initrd 中使用 chroot。

    清单 5. 在 Linux 2.4 内核 initrd 中使用 chroot 的示例

    mount /dev/hda1 /new-root
    cd /new-root
    pivot_root . old-root
    exec chroot . /sbin/init <dev/console >dev/console 2>&1
    umount /old-root

    由于 Linux 内核的升级,initrd 处理机制和格式发生了变化,在 Linux 2.6 内核 initrd 中不能再使用 pivot_root,因此一般也不再使用 chroot,而是选择使用 busybox 提供的 switch_root 或者 klibc 提供的 run-init 进行根目录的切换。(这并不是说不能在 Linux 2.6内核 initrd 中使用 chroot,选择 switch_root 或 run-init 仅是出于习惯和方便的考虑。)但是实质上,它们仅是将 chroot 的功能进行了封装,以此更加方便简单的切换根目录。

    清单 6. 在 Linux 2.6 内核 initrd 中 chroot 的使用

    [1] find -xdev / -exec rm '{}' ';
    [2] cd /newmount; mount --move . /; chroot .

    switch_root 和 run-init 完成了类似清单 6中的功能,删除 rootfs 的全部内容以释放空间,以及挂载新的根文件系统并进行切换。在 busybox 和 klibc中也有提供 chroot 命令,只是功能上与 Coreutils (GNU core utilities) 包含的 chroot 有稍许差异。
    编写一个 chroot

    上面介绍了 chroot 及其使用,但是编写一个简单的 chroot 并不复杂,下面我们就尝试编写chroot 以此来更好的认识 chroot 的处理过程,先编写一个粗略的 chroot 然后再完善它的功能。chroot 的编写涉及了2个函数,chroot() 以及 chdir(),它们都包含在 unistd.h 头文件中。

    清单 7. 编写 chroot 涉及的2个函数

    #include <unistd.h>
    int chroot(const char *path);
    int chdir(const char *path);

    chroot() 将切换参数 path 所指位置为根目录 (/),chdir() 用来将当前的工作目录改变成以参数path 所指的目录。以此我们可以编写一个非常粗略的 chroot

    清单 8. 粗略的 chroot

    #include <unistd.h>
    
    int main(int argc, char *argv[])
    {
        chroot(".");
        chdir("/");
    
        char *arrays[]={"ash",NULL};
        execvp("ash", arrays);
    
        return 0;
    }

    这个粗略的 chroot 仅能切换当前位置为根目录,同时默认执行 ash shell,不包含任何的错误处理及警告。编写并保存代码为 test.c。在清单 9 中,展示了这个粗略 chroot 的使用情况,成功的进行了根目录的切换。

    清单 9. 粗略 chroot 的使用

    $ gcc -Wall test.c -o test
    
    # ./test
    # ls
    ash: ls: not found
    
    # busybox ls
    bin      etc      newhome  test     test.c

    下面给出功能将近完整的 chroot ,加上了一些错误处理并新增了可执行指定命令的功能。当在没有给出 chroot 切换后要执行的命令时,默认执行 /bin/sh,同时检测环境以确认使用何种 shell。

    清单 10. 功能完整的 chroot

    #include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    
    int main(int argc, char *argv[])
    {
        if(argc<2){
            printf("Usage: chroot NEWROOT [COMMAND...] \n");
            return 1;
        }
    
        printf("newroot = %s\n", argv[1]);
        if(chroot(argv[1])) {
            perror("chroot");
            return 1;
        }
    
        if(chdir("/")) {
            perror("chdir");
            return 1;
        }
    
        if(argc == 2) {
            argv[0] = getenv("SHELL");
            if(!argv[0])
                argv[0] = (char *)"/bin/sh";
    
            argv[1] = (char *) "-i";
            argv[2] = NULL;
        } else {
            argv += 2;
        }
    
        execvp (argv[0], argv);
        printf("chroot: cannot run command `%s`\n", *argv);
    
        return 0;
    }

    保存以上代码为 newchroot.c 文件,编译后运行测试其功能。最后要指出的是,本文中的 chroot 并没有使用静态编译。如果有必要(如,在 initrd 中使用 chroot),chroot 应该使用静态编译,若是使用动态编译,那么要拷贝相关的动态库文件到相应目录结构中。

    清单 11. newchroot 的测试

    $ gcc -Wall newchroot.c -o newchroot
    
    # ./newchroot . /bin/ash
    newroot = .
    #
    展开全文
  • chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以 /,即以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将...为什么要使用 chroot 命令增加了系统的安全...

    chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以 /,即以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以指定的位置作为 / 位置。

    基本语法

    chroot NEWROOT [COMMAND [ARG]...]

    具体用法请参考本文的 demo。

    为什么要使用 chroot 命令

    增加了系统的安全性,限制了用户的权力:

    在经过 chroot 之后,在新根下将访问不到旧系统的根目录结构和文件,这样就增强了系统的安全性。一般会在用户登录前应用 chroot,把用户的访问能力控制在一定的范围之内。

    建立一个与原系统隔离的系统目录结构,方便用户的开发:

    使用 chroot 后,系统读取的是新根下的目录和文件,这是一个与原系统根下文件不相关的目录结构。在这个新的环境中,可以用来测试软件的静态编译以及一些与系统不相关的独立开发。

    切换系统的根目录位置,引导 Linux 系统启动以及急救系统等:

    chroot 的作用就是切换系统的根位置,而这个作用最为明显的是在系统初始引导磁盘的处理过程中使用,从初始 RAM 磁盘 (initrd) 切换系统的根位置并执行真正的 init,本文的最后一个 demo 会详细的介绍这种用法。

    通过 chroot 运行 busybox 工具

    busybox 包含了丰富的工具,我们可以把这些工具放置在一个目录下,然后通过 chroot 构造出一个 mini 系统。简单起见我们直接使用 docker 的 busybox 镜像打包的文件系统。先在当前目录下创建一个目录 rootfs:$ mkdir rootfs

    然后把 busybox 镜像中的文件释放到这个目录中:$ (docker export $(docker create busybox) | tar -C rootfs -xvf -)

    通过 ls 命令查看 rootfs 文件夹下的内容:$ ls rootfs

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    万事俱备,让我们开始吧!

    执行 chroot 后的 ls 命令$ sudo chroot rootfs /bin/ls

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    虽然输出结果与刚才执行的 ls rootfs 命令形同,但是这次运行的命令却是 rootfs/bin/ls。

    运行 chroot 后的 pwd 命令$ sudo chroot rootfs /bin/pwd

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    哈,pwd 命令真把 rootfs 目录当根目录了!

    不带命令执行 chroot$ sudo chroot rootfs

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    这次出错了,因为找不到 /bin/bash。我们知道 busybox 中是不包含 bash 的,但是 chroot 命令为什么会找 bash 命令呢? 原来,如果不给 chroot 指定执行的命令,默认它会执行 '${SHELL} -i',而我的系统中 ${SHELL} 为 /bin/bash。

    既然 busybox 中没有 bash,我们只好指定 /bin/sh 来执行 shell 了。$ sudo chroot rootfs /bin/sh

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    运行 sh 是没有问题的,并且我们打印出了当前进程的 PID。

    检查程序是否运行在 chroot 环境下

    虽然我们做了好几个实验,但是肯定会有朋友心存疑问,怎么能证明我们运行的命令就是在 chroot 目录后的路径中呢?

    其实,我们可以通过 /proc 目录下的文件检查进程的中的根目录,比如我们可以通过下面的代码检查上面运行的 /bin/sh 命令的根目录(请在另外一个 shell 中执行):$ pid=$(pidof -s sh)

    $ sudo ls -ld /proc/$pid/root

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    输出中的内容明确的指出 PID 为 46644 的进程的根目录被映射到了 /tmp/rootfs 目录。

    通过代码理解 chroot 命令

    下面我们尝试自己实现一个 chroot 程序,代码中涉及到两个函数,分别是 chroot() 函数和 chdir() 函数,其实真正的 chroot 命令也是通过调用它们实现的:

    #include #include #include 

    int main(int argc, char *argv[])

    {    if(argc<2){

    printf("Usage: chroot NEWROOT [COMMAND...] \n");

    return 1;

    }    if(chroot(argv[1])) {

    perror("chroot");

    return 1;

    }

    if(chdir("/")) {

    perror("chdir");

    return 1;

    }

    if(argc == 2) {        // hardcode /bin/sh for my busybox tools.

    argv[0] = (char *)"/bin/sh";

    argv[1] = (char *) "-i";

    argv[2] = NULL;

    } else {

    argv += 2;

    }

    execvp (argv[0], argv);

    printf("chroot: cannot run command `%s`\n", *argv);

    return 0;

    }

    把上面的代码保存到文件 mychroot.c 文件中,并执行下面的命令进行编译:$ gcc -Wall mychroot.c -o mychroot

    mychroot 的用法和 chroot 基本相同:$ sudo ./mychroot ./rootfs

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    特别之处是我们的 mychroot 在没有传递命令的情况下执行了 /bin/sh,原因当然是为了支持我们的 busybox 工具集,笔者在代码中 hardcode 了默认的 shell:argv[0] = (char *)"/bin/sh";

    从代码中我们也可以看到,实现 chroot 命令的核心逻辑其实并不复杂。

    实例:通过 chroot 重新设置 root 密码

    忘记了 root 密码该怎么办?接下来的 demo 将演示如何通过 chroot 命令重新设置 centos7 中被忘记了的 root 密码。

    systemd 的管理机制中,rescure 模式和 emeryency 模式是无法直接取得 root 权限的,需要使用 root 密码才能进入 rescure 和 emeryency 环境。所以我们需要通过其他方式来设置 root 密码。我们可以为内核的启动指定 "rd.break" 参数,从而让系统在启动的早期停下来,此时我们可以通过使用 root 权限并结合 chroot 命令完成设置 root 密码的操作。下面我们一起来看具体的操作过程。

    在系统启动过程中进入开机菜单时按下字母键 e 进程开机菜单的编辑模式:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    这就是系统的开机菜单,按下 e 后进入编辑界面:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    找到以 "linux16 /vmlinuz-" 开头的行。如果默认没有看到该行,需要按向下键把它滚动出来。

    然后定位到该行结尾处,输入一个空格和字符串 "rd.break",如下图所示:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    接着按下 ctrl + x 以该设置继续启动,启动过程中操作系统会停下来,这是系统启动过程中的一个非常早的时间点:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    所以系统的根目录还挂载在 RAM disk 上(就是内存中的一个文件系统),我们可以通过 mount 命令检查系统当前挂载的文件系统,下面是我们比较关心的两条:

    AAffA0nNPuCLAAAAAElFTkSuQmCC

    上图中 mount 命令输出的第一行说明此时的根目录在一个 RAM disk 中, 即 rootfs。

    图中输出的第二行说明我们的文件系统此时被挂载到了 /sysroot 目录,并且是只读的模式:/dev/mapper/centos-root on /sysroot type xfs (ro,relatime,attr2,inode64,noquota)

    而在我们正常登陆系统的情况下,系统根目录的挂载情况如下:/dev/mapper/centos-root on / type xfs (rw,relatime,seclabel,attr2,inode64,noquota)

    该时间点的最大优势是我们具有 root 权限!所以让我们开始设置新的 root 密码吧。

    先通过下面的命令把 /sysroot 重新挂载为可读写的模式:switch_root:/# mount -o remount,rw /sysroot

    然后用下面 chroot 命令把根目录切换到我们原来的环境中:switch_root:/# chroot /sysroot

    此时可以理解为:我们以 root 权限登录了原来的系统,修改密码就很容易了!用下面的命令为 root 用户设置新的密码:sh-4.2# echo "new_root_pw" | passwd --stdin root

    接下来还要处理 SELinux 相关的问题。由于当前的环境中 SELinux 并未启动,所以我们对文件的修改可能造成文件的 context 不正确。为了确保开机时重新设定 SELinux context,必須在根目录下添加隐藏文件 .autorelabel:sh-4.2# touch /.autorelabel

    最后从 chroot 中退出,并重启系统:sh-4.2# exit

    switch_root:/# reboot

    重新进入登陆界面时就可以使用刚才设置的密码以 root 登陆了!

    总结

    chroot 是一个很有意思的命令,我们可以用它来简单的实现文件系统的隔离。但在一个容器技术繁荣的时代,用 chroot 来进行资源的隔离实在是 low 了点。所以 chroot 的主要用途还是集中在系统救援、维护等一些特殊的场景中。

    展开全文
  • Fatmawati Achmad Zaenuri/Shutterstock.comFatmawati Achmad Zaenuri / Shutterstock.comThe chroot command can send you to jail, keep your development or test environments isolated, or just improve your s...
    A terminal prompt on a Linux laptop's screen.
    Fatmawati Achmad Zaenuri/Shutterstock.com Fatmawati Achmad Zaenuri / Shutterstock.com

    The chroot command can send you to jail, keep your development or test environments isolated, or just improve your system’s security. We show you the easiest way to use it.

    chroot命令可以将您送入监狱,使您的开发或测试环境保持隔离,或者只是提高系统的安全性。 我们向您展示最简单的使用方式。

    什么是chroot? (What’s a chroot?)

    If you try to measure the usefulness of a command, you must take into account the functionality it provides and its ease of use. If it is too complicated for people to use or too long-winded to make them want to try to use it, the functionality might as well be zero. If no one uses it, it doesn’t provide any functionality.

    如果尝试衡量命令的有用性,则必须考虑到该命令提供的功能及其易用性。 如果对于人来说使用它太复杂或太费力以致于他们不想尝试使用它,那么该功能可能也为零。 如果没有人使用它,它将不提供任何功能。

    In discussions with Linux users—in person and on forums—it seems that the chroot command is one that is pegged as being difficult to use, or too persnickety and tedious to setup. It seems this terrific utility isn’t used as much as it might be.

    在与Linux用户的讨论中,无论是在现场还是在论坛上,似乎chroot命令都是一个难于使用的命令,或者安装起来过于麻烦和乏味。 看来,这个实用工具并未得到应有的利用。

    With chroot you can set up and run programs or interactive shells such as Bash in an encapsulated filesystem that is prevented from interacting with your regular filesystem. Everything within the chroot environment is penned in and contained. Nothing in the chroot environment can see out past its own, special, root directory without escalating to root privileges. That has earned this type of environment the nickname of a chroot jail. The term “jail” shouldn’t be confused with FreeBSD’s jail command, which creates a chroot environment that is more secure than the usual chroot environment.

    使用chroot您可以在封装的文件系统中设置和运行程序或交互式shell,例如Bash,以防止与常规文件系统进行交互。 chroot环境中的所有内容都被写入并包含在其中。 如果不升级到root特权, chroot环境中的任何内容都无法超越它自己的特殊根目录。 这为这种类型的环境赢得了chroot监狱的绰号。 术语“ jail”不应与FreeBSD的jail命令混淆,该命令创建的chroot环境比通常的chroot环境更安全

    But actually, there’s a very straightforward way to use chroot, which we’re going to step through. We’re using regular Linux commands which will work on all distributions. Some Linux distributions have dedicated tools to set up chroot environments, such as debootstrap for Ubuntu, but we’re being distro-agnostic here.

    但是实际上,有一种非常直接的方法可以使用chroot ,我们将逐步介绍它。 我们正在使用可在所有发行版上正常运行的常规Linux命令。 一些Linux发行版具有专用的工具来设置chroot环境,例如Ubuntu的debootstrap ,但在这里我们与发行版无关。

    什么时候应该使用chroot? (When Should You Use a chroot?)

    A chroot environment provides functionality similar to that of a virtual machine, but it is a lighter solution. The captive system doesn’t need a hypervisor to be installed and configured, such as VirtualBox or Virtual Machine Manager. Nor does it need to have a kernel installed in the captive system. The captive system shares your existing kernel.

    chroot环境提供的功能类似于虚拟机,但解决方案更轻便。 专属系统不需要安装和配置虚拟机监控程序,例如VirtualBoxVirtual Machine Manager 。 也不需要在自备系统中安装内核。 专属系统共享您现有的内核。

    In some senses, chroot environments are closer to containers such as LXC than to virtual machines. They’re lightweight, quick to deploy, and creating and firing one up can be automated. Like containers, one convenient way to configure them is to install just enough of the operating system for you to accomplish what is required. The “what is required” question is answered by looking at how you’re going to use your chroot environment.

    从某种意义上说, chroot环境比诸如虚拟机更靠近LXC之类的容器。 它们重量轻,部署Swift,并且可以自动创建和启动一个。 像容器一样,一种方便的配置方式是安装足够多的操作系统,以完成所需的操作。 通过查看如何使用chroot环境,可以回答“需要什么”问题。

    Some common uses are:

    一些常见的用途是:

    Software Development and Product Verification. Developers write software and the product verification team (PV) tests it.  Sometimes issues are found by PV that can’t be replicated on the developer’s computer. The developer has all sorts of tools and libraries installed on their development computer that the average user—and PV—won’t have. Often, new software that works for the developer but not for others turns out to be using a resource on the developer’s PC that hasn’t been included in the test release of the software. chroot allows the developers to have a plain vanilla captive environment on their computer that they can sheep-dip the software in before giving it to PV. The captive environment can be configured with the bare minimum dependencies that the software requires.

    软件开发和产品验证。 开发人员编写软件,产品验证团队(PV)对其进行测试。 有时PV发现的问题无法在开发人员的计算机上复制。 开发人员在其开发计算机上安装了普通用户和PV所没有的各种工具和库。 通常,适用于开发人员但不适用于其他开发人员的新软件原来正在使用开发人员PC上的资源,该资源未包含在该软件的测试版本中。 chroot允许开发人员在其计算机上拥有一个普通的香草俘虏环境,他们可以在将该软件提供给PV之前先将其浸入水中。 可以使用软件所需的最低限度依赖项来配置俘虏环境。

    Reducing Development Risk. The developer can create a dedicated development environment so that nothing that happens in it can mess up his actual PC.

    减少发展风险。 开发人员可以创建一个专用的开发环境,以便其中发生的任何事情都不会破坏他的实际PC。

    Running Deprecated Software. Sometimes you just have to have an old version of something running.  If the old software has requirements that would clash or be incompatible with your version of Linux you can chroot an environment for the problem software.

    运行不推荐使用的软件。 有时,您只需要运行旧版本即可。 如果旧的软件有将与您Linux版本冲突或不兼容的要求,你可以chroot的问题,软件的环境。

    Recovery and Filesystem Upgrades: If a Linux installation becomes inoperable, you can use chroot to mount the damaged filesystem to a mount point on a Live CD. This allows you to work in the damaged system and attempt to fix it as though it were mounted normally at root /. This means the expected file paths within the damaged system will be correctly referenced from the root directory, and not from the mount point of the Live CD. A similar technique was used in the article describing how to migrate the Linux filesystem from ext2 or ext3 to ext4.

    恢复和文件系统升级:如果无法进行Linux安装,则可以使用chroot将损坏的文件系统安装到Live CD上的安装点。 这使您可以在损坏的系统中工作,并尝试像在根目录/上正常安装一样对其进行修复。 这意味着将从根目录而不是从Live CD的安装点正确引用损坏的系统中的预期文件路径。 文章中使用了类似的技术,描述了如何将Linux文件系统从ext2或ext3迁移到ext4。

    Ringfencing Applications. Running an FTP server or other internet-connected appliance inside a chroot environment limits the damage an external attacker can do. This can be a valuable step in hardening the security of your system.

    环形防护应用。 在chroot环境中运行FTP服务器或其他与Internet连接的设备会限制外部攻击者可能造成的损害。 这是加强系统安全性的重要步骤。

    创建一个chroot环境 (Creating a chroot Environment)

    We need a directory to act as the root directory of the chroot environment. So that we have a shorthand way of referring to that directory we’ll create a variable and store the name of the directory in it. Here we’re setting up a variable to store a path to the “testroot” directory. It doesn’t matter if this directory doesn’t exist yet, we’re going to create it soon. If the directory does exist, it should be empty.

    我们需要一个目录作为chroot环境的根目录。 为了方便我们引用该目录,我们将创建一个变量并将目录名称存储在其中。 在这里,我们设置一个变量来存储“ testroot”目录的路径。 此目录是否不存在无关紧要,我们将很快创建它。 如果目录确实存在,则应为空。

    chr=/home/dave/testroot
    
    chr=/home/dave/testroot in a terminal window

    If the directory doesn’t exist, we need to create it. We can do that with this command. The -p (parents) option ensures any missing parent directories are created at the same time:

    如果该目录不存在,则需要创建它。 我们可以使用此命令来做到这一点。 -p (父级)选项可确保同时创建所有丢失的父目录:

    mkdir -p $chr
    
    mkdir -p $chr in a terminal window

    We need to create directories to hold the portions of the operating system our chroot environment will require. We’re going to set up a minimalist Linux environment that uses Bash as the interactive shell. We’ll also include the touch, rm, and ls commands. That will allow us to use all Bash’s built-in commands and touch, rm, and ls. We’ll be able to create, list and remove files, and use Bash. And—in this simple example—that’s all.

    我们需要创建目录来保存chroot环境所需的操作系统部分。 我们将建立一个使用Bash作为交互式外壳的极简主义Linux环境。 我们还将包括touchrmls命令。 这将使我们能够使用Bash的所有内置命令以及touchrmls 。 我们将能够创建,列出和删除文件,并使用Bash。 而且,在这个简单的示例中,仅此而已。

    List the directories you need to create within the {} brace expansion.

    列出您需要在{}括号扩展中创建的目录。

    mkdir -p $chr/{bin,lib,lib64}
    
    mkdir -p $chr/{bin,lib,lib64} in a terminal window

    Now we’ll change directory into our new root directory.

    现在,我们将目录更改为新的根目录。

    cd $chr
    
    cd $chr in a terminal window

    Let’s copy the binaries that we need in our minimalist Linux environment from your regular “/bin” directory into our chroot “/bin” directory. The -v (verbose) option makes cp tell us what it is doing as it performs each copy action.

    让我们将极简Linux环境中所需的二进制文件从常规的“ / bin”目录复制到chroot “ / bin”目录中。 -v (详细)选项使cp在执行每个复制操作时告诉我们它在做什么。

    cp -v /bin/{bash,touch,ls,rm} $chr
    
    cp -v /bin/{bash,touch,ls,rm} $chr ina terminal window

    The files are copied in for us:

    这些文件将为我们复制:

    output from cp as files are copied in a terminal window

    These binaries will have dependencies. We need to discover what they are and copy those files into our environment as well, otherwise bash, touch, rm, and ls will not be able to function. We need to do this in turn for each of our chosen commands. We’ll do Bash first. The ldd command will list the dependencies for us.

    这些二进制文件将具有依赖性。 我们需要发现它们是什么并将这些文件也复制到我们的环境中,否则bashtouchrmls将无法运行。 我们需要依次为每个选择的命令执行此操作。 我们将首先进行Bash。 ldd命令将为我们列出依赖项

    ldd /bin/bash
    
    ldd /bin/bash in a terminal window

    The dependencies are identified and listed in the terminal window:

    在终端窗口中标识并列出了依赖性:

    Bash dependencies listed in a terminal window

    We need to copy those files into our new environment. Picking the details out of that listing and copying them one at a time is going to be time-consuming and error-prone.

    我们需要将这些文件复制到我们的新环境中。 从清单中挑选细节并一次复制一个细节将非常耗时且容易出错。

    Thankfully, we can semi-automate it. We’ll list the dependencies again, and this time we’ll form a list. Then we’ll loop through the list copying the files.

    幸运的是,我们可以将其半自动化。 我们将再次列出依赖关系,这次我们将形成一个列表。 然后,我们将遍历复制文件的列表。

    Here we’re using ldd to list the dependencies and feed the results through a pipe into egrep. Using egrep is the same as using grep with the -E (extended regular expressions) option. The -o (only matching) option restricts the output to the matching parts of lines. We’re looking for matching library files that end in a number [0-9].

    在这里,我们使用ldd列出依赖项,并将结果通过管道输入到egrep 。 使用egrep与使用带有-E (扩展正则表达式)选项的grep相同。 -o (仅匹配)选项将输出限制为行的匹配部分。 我们正在寻找以数字[0-9]结尾的匹配库文件。

    list="$(ldd /bin/bash | egrep -o '/lib.*\.[0-9]')"
    
    list="$(ldd /bin/bash | egrep -o '/lib.*\.[0-9]')" in a terminal window

    We can check the contents of the list using echo:

    我们可以使用echo检查列表的内容:

    echo $list
    
    echo $list in a terminal window

    Now that we have the list, we can step through it with the following loop, copying the files one at a time. We’re using the variable i to step through the list. For each member of the list, we copy the file to our chroot root directory which is the value held in $chr.

    现在我们有了列表,我们可以通过以下循环逐步执行该列表,一次复制一个文件。 我们正在使用变量i来遍历列表。 对于列表的每个成员,我们将文件复制到chroot根目录,该目录是$chr保存的值。

    The -v (verbose) option causes cp to announce each copy as it performs it.  The --parents option ensures any missing parent directories are created in the chroot environment.

    -v (详细)选项使cp在执行每个副本时宣布其副本。 --parents选项可确保在chroot环境中创建所有丢失的父目录。

    for i in $list; do cp -v --parents "$i" "${chr}"; done
    
    for i in $list; do cp -v --parents "$i" "${chr}"; done in a terminal window

    And this is the output:

    这是输出:

    output from the cp loop in a terminal window

    We’ll use that technique to capture the dependencies of each of the other commands. And we’ll use the loop technique to perform the actual copying. The good news is we only need to make a tiny edit to the command that gathers the dependencies.

    我们将使用该技术来捕获其他每个命令的依赖性。 然后,我们将使用循环技术执行实际的复制。 好消息是,我们只需要对收集依赖项的命令进行少量编辑即可。

    We can retrieve the command from our command history by hitting the Up Arrow key a few times and then make the edit. The looping copy command doesn’t need to change at all.

    我们可以通过几次单击Up Arrow键从命令历史记录中检索命令,然后进行编辑。 循环复制命令根本不需要更改。

    Here we’ve used the Up Arrow key to find the command, and we’ve edited it to say touch instead of bash.

    在这里,我们使用了Up Arrow键来查找命令,并且对其进行了编辑,使其说成touch而不是bash

    list="$(ldd /bin/touch | egrep -o '/lib.*\.[0-9]')"
    
    list="$(ldd /bin/touch | egrep -o '/lib.*\.[0-9]')" in a terminal window

    We can now repeat the exact same loop command as before:

    现在,我们可以重复与之前完全相同的循环命令:

    for i in $list; do cp -v --parents "$i" "${chr}"; done
    
    for i in $list; do cp -v --parents "$i" "${chr}"; done in a terminal window

    And our files are copied for us:

    并且为我们复制了文件:

    foutput of the cp loop copying the touch dependencies in a terminal window

    We can now edit the list command line for ls:

    现在,我们可以编辑lslist命令行:

    list="$(ldd /bin/ls | egrep -o '/lib.*\.[0-9]')"
    
    list="$(ldd /bin/ls | egrep -o '/lib.*\.[0-9]')" in a terminal window

    Again, we’ll use the same loop command. It doesn’t care what files are in the list. It blindly works through the list copying the files for us.

    同样,我们将使用相同的循环命令。 不在乎列表中有哪些文件。 它会盲目地处理列表,为我们复制文件。

    for i in $list; do cp -v --parents "$i" "${chr}"; done
    
    for i in $list; do cp -v --parents "$i" "${chr}"; done in a terminal window

    And the dependencies for ls are copied over for us:

    ls的依赖项已复制给我们:

    Output from the cp loop copying the ls dependencies in a terminal window

    We edit the list command line for the last time, making it work for rm:

    我们最后一次编辑list命令行,使其适用于rm

    list="$(ldd /bin/ls | egrep -o '/lib.*\.[0-9]')"
    
    list="$(ldd /bin/ls | egrep -o '/lib.*\.[0-9]')" in a terminal window

    We use the looping copy command one last time:

    我们上一次使用循环复制命令:

    for i in $list; do cp -v --parents "$i" "${chr}"; done
    

    The last of our dependencies are copied into our chroot environment. We’re finally ready to use the chroot command. This command sets the root of the chroot environment, and specifies which application to run as the shell.

    我们的最后一个依赖项被复制到chroot环境中。 我们终于可以使用chroot命令了。 此命令设置chroot环境的根目录,并指定要作为外壳程序运行的应用程序。

    sudo chroot $chr /bin/bash
    
    sudo chroot $chr /bin/bash  in a terminal window

    Our chroot environment is now active. The terminal window prompt has changed, and the interactive shell is the being handled by the bash shell in our environment.

    我们的chroot环境现在处于活动状态。 终端窗口提示已更改,并且交互式shell由我们环境中的bash shell处理。

    Active chroot environment in a terminal window

    We can try out the commands that we have brought into the environment.

    我们可以尝试引入环境中的命令。

    ls
    
    ls /home/dave/Documents
    
    Active chroot environment in a terminal window

    The ls command works as we’d expect when we use it within the environment. When we try to access a directory outside of the environment, the command fails.

    当在环境中使用ls命令时,它的工作与预期的一样。 当我们尝试访问环境外部的目录时,命令失败。

    We can use touch to create a file, ls to list it, and rm to remove it.

    我们可以使用touch创建一个文件,使用ls列出它,使用rm删除它。

    touch sample_file.txt
    
    ls
    
    rm sample_file.txt
    
    ls
    
    touch sample_file.txt in a terminal window

    Of course, we can also use the built-in commands that the Bash shell provides. If you type help at the command line, Bash will list them for you.

    当然,我们也可以使用Bash shell提供的内置命令。 如果您在命令行输入help ,Bash将为您列出它们。

    help
    
    Output of the help command in a terminal window

    Use exit to leave the chroot environment:

    使用exit离开chroot环境:

    exit
    
    using exit to leave teh chroot environment in a terminal window

    If you want to remove the chroot environment, you can simply delete it:

    如果要删除chroot环境,只需删除它即可:

    rm -r testroot/
    
    rm -r testroot/ in a terminal window

    This will recursively delete the files and directories in the chroot environment.

    这将递归删除chroot环境中的文件和目录。

    自动化便利 (Automate for Convenience)

    If you’re thinking that chroot environments might be useful to you, but they’re a bit fiddly to set up, remember that you can always take the strain and the risk out of repetitive tasks by using aliases, functions, and scripts.

    如果您认为chroot环境可能对您有用,但是设置起来有些麻烦,请记住,您始终可以使用别名,函数和脚本来减轻重复性任务的负担和风险。

    翻译自: https://www.howtogeek.com/441534/how-to-use-the-chroot-command-on-linux/

    展开全文
  • Linux chroot命令

    千次阅读 2019-07-07 10:35:39
    什么是 chroot chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以/,即是以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以指定的位置作为/位置。 图 ...
  • chroot 命令,可以用它来简单的实现文件系统的隔离,但在一个容器技术繁荣的时代,用 chroot 来进行资源的隔离实在是有点太low 了,chroot 主要用途还是集中在系统救援、维护等一些特殊的场景中。 ...
  • do_filp_open path_openat path_init 函数 chroot 创建的程序其子程序也同样被隔离到指定目录中的原因 总结 基础知识 linux 命令分析之 chroot 的原理 目录访问的原理 关于目录访问的原理,我选择从《Linux 内核源...
  • linux chroot 命令 设置根目录路径

    千次阅读 2020-02-26 12:46:42
    chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以 /,即以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以指定的位置作为 ...为什么要使用 chroot 命令...
  • linux chrootLinux provides different mechanisms for practical and security reasons. chrootis one of them. Processes in linux can access to the file system or root by default. Linux kernel also provid....
  • linux chroot 命令

    2018-03-15 10:32:00
    chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以 /,即以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以指定的...为什么要使用 chroot 命令 增加了...
  • chroot 命令小记

    2018-04-17 15:32:45
    什么是 chroot chroot 最早是作为系统调用引入 1979 年的 Unix V7 系统,目的是为了将当前进程及其子进程的 root 目录重定向到某个指定目录。1982 年,chroot 功能被加入到 BSD 中,后经 20 多年,FreeBSD 团队引入...
  • chroot命令详解

    2019-10-15 16:00:12
    转自
  • linux chrootSometimes, you may need to isolate a process from ... We can do this with the use of the chroot command in Linux. 有时,您可能需要将一个进程与系统上运行的其他进程隔离。 我们可以在Linux...
  • linux chroot命令使用

    千次阅读 2019-04-23 14:13:30
    什么是 chroot chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以 `/`,即是以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以指定的位置作为 `/` 位置...
  • chroot 命令

    2014-07-08 18:23:09
    chroot’使用一个指定的根目录运行命令,在大多数系统上,仅限于超级用户可以做这个动作。 通常情况下,搜索文件名开始于根目录结构。比如‘/’。‘chroot命令可以更改根路径到新的指定的路径。 使用chroot,...
  • linux之chroot命令

    2022-04-13 21:12:17
    chroot 命令 用来在指定的根目录下运行指令。chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以/,即是以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构...
  • chroot命令的基本用法

    千次阅读 2016-04-12 15:47:43
    chroot】切换根目录 chroot /PATH/TO/TEMPROOT [COMMAND...] chroot /test/virrot /bin/bash //切换根目录,并明确指明运行那个目录下面的bash ---------------------例子,切换根目录---------------...
  • chroot命令用来在指定的根目录下运行指令。chroot,即 change root directory (更改 root 目录)。在 linux 系统中,系统默认的目录结构都是以/,即是以根 (root) 开始的。而在使用 chroot 之后,系统的目录结构将以...
  • chroot 命令实例讲解

    2019-09-26 01:04:28
    我要怎样改变一个进程的根目录呢,比如用 chroot 命令将web服务与文件系统隔离?我要如何使用 chroot 恢复密码或修复基于 Linux/Unix的受损坏的环境? 在 Linux和类 Unix 系统下每一个进程/命令的当前工作目录称...
  • Linux chroot 命令

    2022-01-12 21:45:43
    Linux命令是对Linux系统进行管理的命令。对于Linux系统来说,无论是中央处理器、内存、磁盘驱动器、键盘、鼠标,还是用户等都是文件,Linux系统...本文主要介绍Linux chroot 命令。 原文地址:Linux chroot 命令 ...
  • linux 命令chroot详解

    2021-12-14 22:48:35
    linux 命令chroot详解

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 44,344
精华内容 17,737
关键字:

chroot命令

友情链接: 4.zip