ctfshow密码学做题笔记及代码整理

【Qt】从C++11到C++20:Qt版本与现代C++特性的深度适配指南 本文深入探讨了Qt框架从C++11到C++20的版本演进与现代C++特性的深度适配。详细解析了Qt 5.x到Qt 6.x系列对C++标准的支持变化,包括C++11的Lambda表达式、C++17的结构化绑定以及C++20的协程等关键特性在Qt中的实战应用。通过构建系统配置指南和版本迁移策略,帮助开发者高效利用现代C++提升Qt开发效率与性能。 阅读详情

1.颜文字解密

2.RSA——Python

3.U2FsdGVkX1开头——rabbit,AES,DES

4.暴力破解压缩包密码


5.serpent压缩包名即为解密方式,ECB不需要偏移

6.解码整理:

(1)一个%:utf8:urllib库里的unquote函数

(2)两个%:gb

(3)&#x:UTF8,&#:Unicode

(4)MD5码解密不一定需要32位或者16位

(5)仅有小写字母与数字组成的密文,我们可以想到MD5,hex,键盘密码等等

10.rot移位密码解密:(hou_mian_shi_flag)b%&(@f!&@$%f%e^#

11.内部赛 签到

因为包含有大小写字母,数字,最后有等号,所以首先base64解码

因为包含有很多百分号,且联想到所有的空格符、标点符号、特殊字符以及其他非ASCII字符都将被转化成**%xx格式**的字符编码,所以使用escape解密

因为多了许多特殊符号,所以使用base92解密

得到一串数字,所以十进制转十六进制,再url解码

得到一堆星座,所以根据星座顺序得到12进制数字串,转十六进制,再转ASCII

得到数字和大写字母,再base16解密

12.内部赛 密码2

因为只有ctf和show,所以联想到摩斯密码

转化后得到:

..-.
.-..
.-
--.
----- ----- --... -...
--... ...-- -.-. -..
-.... ----- -.. -.-.
--... --... ...-- -.-.
..... ..--- ....- -..
....- . -... .-
----- ----- --... -..
1
2
3
4
5
6
7
8
9
10
11
..-./.-../.-/--./-----/-----/--.../-.../--.../...--/-.-./-../-..../-----/-../-.-./--.../--.../...--/-.-./...../..---/....-/-../....-/./-.../.-/-----/-----/--.../-../
1
F L A G 0 0 7 B 7 3 C D 6 0 D C 7 7 3 C 5 2 4 D 4 E B A 0 0 7 D 
1
13.BJDCTF2020 编码与调制

首先了解曼彻斯特编码,10为1,01为0

将密文转化为2进制,再两位进行一个划分进行曼彻斯特编码,再转化为十六进制,再转ASCII

脚本:

x='2559659965656A9A65656996696965A6695669A9695A699569666A5A6A6569666A59695A69AA696569666AA6'
strr=bin(int(x,16))[2:]
print(strr)

step = 2
str2 = [strr[i:i+step] for i in range(0,len(strr),step)]
print(str2)
flag = []
final = ""
for i in str2:
    flag.append(i)
for i in flag:
    if(i=="10"):
        final += "1"
    if(i=="01"):
        final += "0"
print(hex(int(final,2)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
14.BJDCTF2020 Polybius

波利比奥斯方阵密码Polybius:一般解密出来是14位

由于不知道aeiou的顺序所以分类

引用代码:

import itertools
ciper = 'ouauuuoooeeaaiaeauieuooeeiea'
head = 'aeoiu'
headlist = []
num_headlist = []

# 先列举处aeiou五种的不同排序
x = itertools.permutations(head,5)
for i in x:
    temp = "".join(i)
    headlist.append(temp)
print(headlist)

# 根据aeiou对应的12345修改ciper的对应值,便于后续的遍历得到结果
for i in headlist:
    temp = ''
    for j in ciper:
        temp += str(i.index(j) + 1)        
    num_headlist.append(temp)
print(num_headlist)

# 将ciper对应的数字乘上比例加上96再转为ASCII码,即 可得到对应的字母
for i in num_headlist:
    temp = ''
    for j in range(0,len(i),2):
        xx = (int(i[j]) - 1)*5 + int(i[j+1]) + 96   # 前一个为乘上5加上后一个就正好对应了表格中的字母
        if xx>ord('i'):
            xx+=1
        temp += chr(xx)
    print(temp)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
15.BJDCTF2020 这是base?

该题即是修改了base64的顺序

引用脚本:

import base64
#dict={0: 'J', 1: 'K', 2: 'L', 3: 'M', 4: 'N', 5: 'O', 6: 'x', 7: 'y', 8: 'U', 9: 'V', 10: 'z', 11: 'A', 12: 'B', 13: 'C', 14: 'D', 15: 'E', 16: 'F', 17: 'G', 18: 'H', 19: '7', 20: '8', 21: '9', 22: 'P', 23: 'Q', 24: 'I', 25: 'a', 26: 'b', 27: 'c', 28: 'd', 29: 'e', 30: 'f', 31: 'g', 32: 'h',33: 'i', 34: 'j', 35: 'k', 36: 'l', 37: 'm', 38: 'W', 39: 'X', 40: 'Y', 41: 'Z', 42: '0', 43: '1', 44: '2', 45: '3', 46: '4', 47: '5', 48: '6', 49: 'R', 50: 'S', 51: 'T', 52: 'n', 53: 'o', 54: 'p', 55: 'q', 56: 'r', 57: 's', 58: 't', 59: 'u', 60: 'v', 61: 'w', 62: '+', 63: '/', 64: '='}
dict='JKLMNOxyUVzABCDEFGH789PQIabcdefghijklmWXYZ0123456RSTnopqrstuvw+/='
base64_list = ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P','Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f','g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v','w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/']
cipher='FlZNfnF6Qol6e9w17WwQQoGYBQCgIkGTa9w3IQKw'
res=''
for i in range(len(cipher)):
    for j in range(64):
        if(dict[j]==cipher[i]):
            res+=base64_list[j]
print(res)
flag=base64.b64decode(res)
print(flag)
#b'BJD{D0_Y0u_kNoW_Th1s_b4se_map}'
1
2
3
4
5
6
7
8
9
10
11
12
13
14
16.BJDCTF2020 伏羲六十四卦

打开压缩包得到一个脚本和一个文本

17.BJDCTF2020 easyrsa

拿到这道题首先看代码,整体思路是根据output倒推回flag

再了解不认识的函数

from Crypto.Util.number import getPrime,bytes_to_long
from sympy import Derivative
from fractions import Fraction
#from secret import flag

p=getPrime(1024)
q=getPrime(1024)
e=65537
n=p*q
z=Fraction(1,Derivative(arctan(p),p))-Fraction(1,Derivative(arth(q),q))
m=bytes_to_long(flag)
c=pow(m,e,n)
print(c,z,n)
1
2
3
4
5
6
7
8
9
10
11
12
13
首先getprime即取一定位数范围下的素数,这里可以认为取p,q两个较大素数

z是与p,q有关系的变量,Derivative()是求导函数,Fraction(a,b)相等于a/b,这里有三个参数,第一个是分子,第二个是分母,p代表参数

经过计算可知z = p2-q2

所以p,q可用z,n表示

引用脚本:

import gmpy2
from Crypto.Util.number import *

c = 7922547866857761459807491502654216283012776177789511549350672958101810281348402284098310147796549430689253803510994877420135537268549410652654479620858691324110367182025648788407041599943091386227543182157746202947099572389676084392706406084307657000104665696654409155006313203957292885743791715198781974205578654792123191584957665293208390453748369182333152809882312453359706147808198922916762773721726681588977103877454119043744889164529383188077499194932909643918696646876907327364751380953182517883134591810800848971719184808713694342985458103006676013451912221080252735948993692674899399826084848622145815461035
z = 32115748677623209667471622872185275070257924766015020072805267359839059393284316595882933372289732127274076434587519333300142473010344694803885168557548801202495933226215437763329280242113556524498457559562872900811602056944423967403777623306961880757613246328729616643032628964072931272085866928045973799374711846825157781056965164178505232524245809179235607571567174228822561697888645968559343608375331988097157145264357626738141646556353500994924115875748198318036296898604097000938272195903056733565880150540275369239637793975923329598716003350308259321436752579291000355560431542229699759955141152914708362494482
n = 15310745161336895413406690009324766200789179248896951942047235448901612351128459309145825547569298479821101249094161867207686537607047447968708758990950136380924747359052570549594098569970632854351825950729752563502284849263730127586382522703959893392329333760927637353052250274195821469023401443841395096410231843592101426591882573405934188675124326997277775238287928403743324297705151732524641213516306585297722190780088180705070359469719869343939106529204798285957516860774384001892777525916167743272419958572055332232056095979448155082465977781482598371994798871917514767508394730447974770329967681767625495394441

x = gmpy2.iroot(z + 2 * n, 2)[0]
y = gmpy2.iroot(z - 2 * n, 2)[0]
e = 65537
p = (x + y) // 2
q = x - p
d = gmpy2.invert(e, (p - 1) * (q - 1))
print(long_to_bytes(pow(c, d, n)))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
18.36D杯 签到

根据提示rot47解码-将符号对应改为键盘数字-base解码

19.36D杯 rsaEZ

压缩包包含三个加密后的密文文件和一个公钥文件,所以解析出e,n,再解出明文即可

引用脚本:

from Crypto.PublicKey import RSA
from Crypto.Util.number import *
import gmpy2
 
publickey = RSA.importKey(open(r'F:\ctf comp\Crypto\题目\flag\fujian\public.key','rb').read())
e = publickey.e
n = publickey.n
p = 302825536744096741518546212761194311477
q = 325045504186436346209877301320131277983
c1 = bytes_to_long(open(r'F:\ctf comp\Crypto\题目\flag\fujian\encrypted.message1','rb').read())
c2 = bytes_to_long(open(r'F:\ctf comp\Crypto\题目\flag\fujian\encrypted.message2','rb').read())
c3 = bytes_to_long(open(r'F:\ctf comp\Crypto\题目\flag\fujian\encrypted.message3','rb').read())
 
d = gmpy2.invert(e,(p-1)*(q-1))
m1 = pow(c1,d,n)
m2 = pow(c2,d,n)
m3 = pow(c3,d,n)
print(long_to_bytes(m1))
print(long_to_bytes(m2))
print(long_to_bytes(m3))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
20.36D杯 justshow

观察26个字母向后移了一位,所以变换密文

得到gkbfnxeripjmxhemoc

再使用playfair密码解密得到明文

flagisctfshowicome

21.36D杯 飞鸽传书

打开文本文件,看到了大小写字母,数字,等号,base64,解密完之后还是大小写字母数字,再解密一次,得到包含许多%0A的数据,所以URL解码,得到八个32位字符串,所以MD5解密得到flag

22.密码学AK赛 加法

键盘位置向左移一位得到flag

23.密码学AK赛 乘法

3%20%6%19%8%15%23%6%12%1%7%9%19%8%5%18%5%

%5%18%5%8%19%9%7%1%12%6%23%15%8%19%6%20%3

24.月饼杯 中秋月

拿到题看提示,提示说该古典密码的密钥形式:keyword+plaintext (+plaintext…+plaintext)

猜测是自动密钥加密,所以思路就是由密文还原得到明文,因为提示说古典密码加密之后密文全是大写,所以需要得到全是大写字母的密文,所以再根据题目自动钥匙有异或的标志,所以将

fsskryenvkm~jl{ejs}jwflzsnpgmifq{{j{|suhzrjppnx|qvixt~whu
1
由异或换为全是大写字母

脚本:

s='fsskryenvkm~jl{ejs}jwflzsnpgmifq{{j{|suhzrjppnx|qvixt~whu'
for i in range(255):
    res=''
    for j in range(0,len(s)):
        temp = ord(s[j])^i
        if 65<=temp<=90 or 97<=temp<=122:    #由大小写字母构成
            res += (chr(temp))
    if len(res)==len(s):
        print(res)
1
2
3
4
5
6
7
8
9
ylltmfzqitrausdzulbuhyselqoxrvynddudcljwemuooqgcnivgkahwj
YLLTMFZQITRAUSDZULBUHYSELQOXRVYNDDUDCLJWEMUOOQGCNIVGKAHWJ
1
2
再用自动密钥解密:

脚本:

from ngram_score import ngram_score
from pycipher import Autokey
import re
from itertools import permutations

qgram = ngram_score('quadgrams.txt')
trigram = ngram_score('trigrams.txt')
ctext = 'YLLTMFZQITRAUSDZULBUHYSELQOXRVYNDDUDCLJWEMUOOQGCNIVGKAHWJ'
ctext = re.sub(r'[^A-Z]', '', ctext.upper())


# keep a list of the N best things we have seen, discard anything else
class nbest(object):
    def __init__(self, N=1000):
        self.store = []
        self.N = N

    def add(self, item):
        self.store.append(item)
        self.store.sort(reverse=True)
        self.store = self.store[:self.N]

    def __getitem__(self, k):
        return self.store[k]

    def __len__(self):
        return len(self.store)


# init
N = 100
for KLEN in range(8, 20):
    rec = nbest(N)

    for i in permutations('ABCDEFGHIJKLMNOPQRSTUVWXYZ', 3):
        key = ''.join(i) + 'A' * (KLEN - len(i))
        pt = Autokey(key).decipher(ctext)
        score = 0
        for j in range(0, len(ctext), KLEN):
            score += trigram.score(pt[j:j + 3])
        rec.add((score, ''.join(i), pt[:30]))

    next_rec = nbest(N)
    for i in range(0, KLEN - 3):
        for k in range(N):
            for c in 'ABCDEFGHIJKLMNOPQRSTUVWXYZ':
                key = rec[k][1] + c
                fullkey = key + 'A' * (KLEN - len(key))
                pt = Autokey(fullkey).decipher(ctext)
                score = 0
                for j in range(0, len(ctext), KLEN):
                    score += qgram.score(pt[j:j + len(key)])
                next_rec.add((score, key, pt[:30]))
        rec = next_rec
        next_rec = nbest(N)
    bestkey = rec[0][1]
    pt = Autokey(bestkey).decipher(ctext)
    bestscore = qgram.score(pt)
    for i in range(N):
        pt = Autokey(rec[i][1]).decipher(ctext)
        score = qgram.score(pt)
        if score > bestscore:
            bestkey = rec[i][1]
            bestscore = score
    print(bestscore, 'autokey, klen', KLEN, ':"' + bestkey + '",', Autokey(bestkey).decipher(ctext).lower())
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
这里需要的是要配置文件和修改代码,将以下文件放同一目录下

ngram_score.py,quadgrams.txt,trigrams.txt

由于Python3已经不支持itervalues()了,所以把iter去掉。

24.月饼杯 月自圆

拿到题目给出的代码,可以知道明文长度为71位,加密后为142位。a是一个50到100的随机数,salt是随机的四位大写字母,这里我不是很明白cycle函数,所以需要去学习itertools库及循环迭代器。
这里由于a不大,salt长度也不长,且明文m中存在flag,正好可以用这几位去爆破出a和salt。
flag在明文m中的位置是53,对应密文c中的位置是105,根据代码下方的注释,可以知道第105位开始是1c29,

引用脚本进行爆破:

from random import *
from string import *
from itertools import *

def decrypt(m, a, si):
    c=""
    for i in range(len(m)):
        c+=hex(((ord(m[i])) * a + ord(next(si))) % 128)[2:].zfill(2)
    return c

if __name__ == "__main__":
    for i in range(50,100):
        for j in ascii_uppercase:
            si = cycle(j.lower())
            # if encrypt('f', i, si)=='1c':
            #     print('i =',i,'\tj =',j)

            if decrypt('l', i, si)=='29':
                print('i =',i,'\tj =',j)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
根据运行结果发下a=67,

继续爆破salt的后两位:

if decrypt('a', 67, si)=='56':
    print('j =',j)

if decrypt('g', 67, si)=='66':
    print('j =',j)
1
2
3
4
5
解密:

from random import *
from string import *
from itertools import *

def decrypt(m, a, si):
    c=""
    for i in range(len(m)):
        c+=hex(((ord(m[i])) * a + ord(next(si))) % 128)[2:].zfill(2)
    return c

if __name__ == "__main__":
    a=67
    salt = 'JESQ'
    si = cycle(salt.lower())
    c = '3472184e657e50561c481f5c1c4e1938163e154431015e13062c1b073d4e3a444f4a5c5c7a071919167b034e1c29566647600c4e1c2956661b6c1f50622f0016317e563546202a'
    q=len(c)//2
    s=''
    for i in range(q):
        b=c[:2]
        c=c[2:]
        sm=next(si)
        for k in range(1,126):
            m=chr(k)
            c1=hex(((ord(m)) * a + ord(sm)) % 128)[2:].zfill(2)
            #print(m,c1,int(c1,base=16)==int(b,base=16))
            if(int(c1,base=16)==int(b,base=16)):
                s+=m
                break
    print(s)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
得到

now_is_7fad9fcb-d361-4964-821c-177c906b8d20_flag_is_flag{md5(now-salt)}

得到now,所以md5加密now-salt,salt是JESQ

25.月饼杯 多少离怀

伽马函数Γ(x)和阶乘x!的关系式
gamma(n)=(n-1)!

威尔逊定理
当且仅当p为素数时:(p-1)! ≡ -1 (mod p)
推论:(p-2)! ≡ 1 (mod p)

欧拉函数
若n是质数p的k次幂,phi = p^k - p^(k-1)

需要求gamma(B+2)%A,根据伽马函数Γ(x)和阶乘x!的关系式可知(B+1)! % A。
而根据威尔逊定理可知(A-2)! % A = 1。
令x = (A-2)!/(B+1)!``,y = (B+1)!,所以x * y ≡ 1 (mod A)。
而我们需要求的是y % A,y是x关于A的逆元。所以求x % A的逆元即可,用欧几里得法求逆.

引用脚本:

import random
import gmpy2
from math import gamma
from Crypto.Util.number import getPrime, isPrime
#参考大佬的exp完善了一下,2333

def getNewPrime():
    A = getPrime(512)
    B = nextPrime(A - random.randint(1e4, 1e5))
    return nextPrime(gamma(B + 2) % A)

def nextPrime(n):
    n += 2 if n & 1 else 1
    while not isPrime(n):
        n += 2
    return n

def getNewPrime2(A, B):
    return nextPrime(gamma2(B, A))

def gcd(a, b):
    while a != 0:
        a, b = b % a, a
    return b

def findModReverse(a, m):  # 这个扩展欧几里得算法求模逆
    if gcd(a, m) != 1:
        return None
    u1, u2, u3 = 1, 0, a
    v1, v2, v3 = 0, 1, m
    while v3 != 0:
        q = u3 // v3
        v1, v2, v3, u1, u2, u3 = (u1 - q * v1), (u2 - q * v2), (u3 - q * v3), v1, v2, v3
    return u1 % m

def gamma2(b, a):
    res = 1
    # print("final: "+str(a-2+1))
    for i in range(b + 2, a - 2 + 1):
        res = (res * findModReverse(i, a)) % a
    # print(i)
    return res

e = 0x10001
pA = 6814157460586876042804041951834304833424062437744287469257313954502540797027261340622077218188033865281590529907571701131297782609357118357982463723982789
pB = 6814157460586876042804041951834304833424062437744287469257313954502540797027261340622077218188033865281590529907571701131297782609357118357982463723922147
qA = 7145646366857234331692232566211321498245533826533958883943688415057871253511271731661019642050252046201115975396366275083424623329930477623781348477881291
qB = 7145646366857234331692232566211321498245533826533958883943688415057871253511271731661019642050252046201115975396366275083424623329930477623781348477807457
n = 4451906216583258787166698210560165433649728830889954633721198623488802305844782492171757604711145165920462286487680020347239300947225371917344589502941576734875830871998499135120227347066586066943289430156378296665669974728569678779668142712266780949126509440672273927433367293606776081254094682033167575930701870261219046464773708974194213798032346187463443317770758989273370488582862531630356263732232300508706676725203199729764016766683870925164232508407363688370458877688991733322055785233669885166225464068579486683574954699370175267031949720967812902215635630884502987094547523361027411501285252862476410213277925430392164226297316310465146003494714018456407793759170649913180823814850170639706664167149612984905056804131124522209409607977589884632999710708045656852149371030046919242039957767777840304466948549383597755811307383659188216421501912831203089570725388153416013596114462069777713822433178099904907224119
c = 1996198968748552041728429851810599627895157160099076033250854211280074825148767841655949210593646824507865483166496070951130337321360509148527292165245205219296211294789087358959553387392928560150390604911087085313000622842025416521494799132969818997182731021267942464323979261593380113740152841984062184326431879167516288834455296913822921806893572566867611541664848820247889274979245086440402996661226884320574824077910315143756471444347386795428338020162169391827182914043434253974549636668126789355991920452920806351939782281969098470635517019120996509180703896707990501216102290302162705699788457579330150149320348175742131887213742989509004374645723471497302400169849858253644606818874098604333865973357374444445825761600866472906771935670261641342221394488068630591190697667016958881530367047928341661857241378511420562236766886349565409774340321441504290366223243635878057759623855735794209219474650425139791831374

#求 ((pA-2)!/(pB+1)!)%pA 的逆元,等于((pB+1)!)%pA ,等于gamma(pB+2)%pA
p = 1
max = (pA-2) - (pB+1)
for i in range(0,max):
    p = p * gmpy2.invert((pA-i-2),pA) % pA
p = nextPrime(p)
#print(p)
#求 ((qA-2)!/(qB+1)!)%qA 的逆元,等于((qB+1)!)%qA ,等于gamma(qB+2)%qA
q = 1
max = (qA-2) - (qB+1)
for i in range(0,max):
    q = q * gmpy2.invert((qA-i-2),qA) % qA
q = nextPrime(q)
#print(q)
#p = 721295413363782943575290202453254405609384962866760177823574558139524613289380285395875654962467791028293949737699221240830187032744030384932819874799211
#q = 3112046822677655775872849946553212669700408142233774149727014153992463597788397754366224491840784669131576610049264423785236897140841668817147645049635999

fn = getNewPrime2(p,q)
#print(fn)
#fn = 3
r = gmpy2.iroot(gmpy2.mpz(n//(p*q*q)),3)[0]
#print(r)
#r = 8605581006163978513558138296576032102733660218879126657600237911024254611499452345790192297532366960817162346945271546520036031830535178172751208076290109

phi = (p - 1) * (q * q - q) * (r * r * r - r * r)
d = gmpy2.invert(e,phi)
#print(d)
#d=3893796118845369439235581551299559681130294433914324573287346480568253612056224380636546037500153379857589128641230243165297526124111655151656456885394718320571011164662139031101601805935834789093718455506105414382703229813895443438508544153175032701351201540968823002419519523214390287666578730407931246445871807183537209694071828922295499346083880163169003198594519162159452952535381034048239423912932288087394862004236172433929593269810986943713662824358214779552898877881697861535560993274391395357266197384454357803117633435524780866783488594161973423232638616086772861225974312225600055495130373828730995856136891951667049900975798958834487417185610258985145585210434281769923883162243531194314167637519779543778335295761192135358383400455687647479329697758466764046259467201396085554561420952266156396111233306174055533779858729332820780458072338771340688204365931674201918683102590056383442579221021315973279544753
m = pow(c, d, n)

import binascii
print(binascii.unhexlify(hex(m)[2:]))

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
25.1024杯 麻辣兔头第七锅

查看题目文本文件,一堆字母,再看一遍题目发现栅栏,直接引用暴力栅栏脚本

def zhalan(s):
    for i in range(1,len(s)):
        f = i    #栅栏的栏数
        elen = len(s)
        b = elen // f
        result = {x:'' for x in range(b)}
        for i in range(elen):
            a = i % b
            result.update({a: result[a] + s[i]})
        d = ''
        for i in range(b):
            d = d + result[i]
        f = open('a.txt','a+')
        f.write(d+'\n')
        f.close()

s ='''Csoe lnno,pdsad u l tr srietaetust ht hce teiteh bomoh  oe  neppfcdw  uroiitcrimstoasnesh uucso wsii lahetpnvnis leeoc oec thwfseth h  shetiHaserhcana ,ehpdrp   p oaLiiolnamnridwpegt sesait lsncoo .ia ftfzla hli sNeanbsamggout { nmut8iderocts e 5s a t6 wmahdphone4oind awcg sbeh oe3r tfpesh ad eNr8i aa4nPttf oui8swroeueenbcr'.7hssWd   e2foG bofohcr do7mt l3,hed6 en 7a tt2seih8 ate1trls4oteed h  5t,tt}h hrTeteuhmhmta e,hts  s hsa tae tolpdo lae s rcbesaeecen uetsrm ee rl meftos-hspeetevs cieltd i erktnieotgl ,hyt t htsteh,o a  otGep ofiavfnleeilrco ntnmm seet nnho tefasi r rmea a rSnceakr fieienantdtsy et rdiae tnqeuduqt iueHradael ps,ap  mittonhhneaagstt s  M.tte hhnPee,ry u ddaeerrneic veei,nn dgio nwtdehedee idbr,y   jwtuihsletli  rpd oiCwcreteraastt eof rrt ohwmai ttt hhG eoc vecerortnnasmieennn ttu sno afll oitnehgne a ebgsloteva ebRrlinigeshdht.eshd,a  tst hhwoahutel ndae mvnoeonrtg   abtnehy e csfheoa rnamgr eeod f L fiGoforev elringmhetn ta nbde ctormaenss ideenstt rcuacutsievse;  oafn dt haecsceo rednidnsg,l yi ta lils  etxhpee rRiiegnhcte  ohfa st hseh oPweno,p lteh atto  maalntkeirn do ra rteo  maobroel idsihs piots,e da ntdo  tsou fifnesrt,i twuhtiel en eewv iGlosv earrnem esnutf,f elraaybilneg,  itthsa n to right themselves by abolishing the forms to which they are accustomed. But when a long train of abuses and usurpations, pursuing invariably the same Object, evinces a design to reduce them under absolute Despotism, it is their ri'''
zhalan(s)
print('success')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
得到文本文件,搜索flag,{,},猜测是32位的md5值

ECB模式攻击

ECB加密

ecb模式使用相同的key分块对明文分别进行加密,相同的明文获得相同的密文输出。

加密条件

1、明文分块长度一般为16,或16的倍数
2、明文长度不满16,或16的倍数,使用填充(具体看算法。默认是\x00)

加密过程
Plaintext: 待加密的数据。
Key : 被一些如AES的对称加密算法使用。
Ciphertext:加密后的数据。
首先将明文进行分块成Plaintext = Plaintext0+Plaintext1+…Plaintextn.

Ciphertext0 = Encrypt(Plaintext0)
Ciphertext1 = Encrypt(Plaintext1)
.....
Ciphertextn = Encrypt(Plaintextn)
1
2
3
4
Ciphertext = Ciphertext0+Ciphertext1+…+Ciphertextn

解密过程

Plaintext0= Decrypt(Ciphertext0)
Plaintext1= Decrypt(Ciphertext1)
.....
Plaintextn= Decrypt(Ciphertextn)
1
2
3
4
ss’)


得到文本文件,搜索flag,{,},猜测是32位的md5值

26.

ECB模式攻击

ECB加密

ecb模式使用相同的key分块对明文分别进行加密,相同的明文获得相同的密文输出。

加密条件

1、明文分块长度一般为16,或16的倍数
2、明文长度不满16,或16的倍数,使用填充(具体看算法。默认是\x00)

加密过程
Plaintext: 待加密的数据。
Key : 被一些如AES的对称加密算法使用。
Ciphertext:加密后的数据。
首先将明文进行分块成Plaintext = Plaintext0+Plaintext1+...Plaintextn.

```c
Ciphertext0 = Encrypt(Plaintext0)
Ciphertext1 = Encrypt(Plaintext1)
.....
Ciphertextn = Encrypt(Plaintextn)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
Ciphertext = Ciphertext0+Ciphertext1+…+Ciphertextn

解密过程

Plaintext0= Decrypt(Ciphertext0)
Plaintext1= Decrypt(Ciphertext1)
.....
Plaintextn= Decrypt(Ciphertextn)
1
2
3
4
Plaintext = Plaintext0 + Plaintext1 +… +Plaintextn
————————————————
版权声明:本文为优快云博主「LLL_0516」的原创文章,遵循CC 4.0 BY-SA版权协议,转载请附上原文出处链接及本声明。
原文链接:https://blog.youkuaiyun.com/qq_51352283/article/details/127803033

CTFshow_萌新--密码篇 ctfshow_萌新 密码篇 阅读详情

相关推荐

CTFshow菜狗杯全题型复盘:从Web到逆向的基础题盛宴

CTF竞赛是检验安全基础知识的有效方式,涉及Web漏洞利用、流量分析、隐写术、逆向工程等多个领域。SQL注入与SSRF等经典漏洞原理,是理解Web安全的核心起点。通过掌握联合查询、报错注入、Gopher协议构造Redis命令等实战技术,安全人员能快速定位内网风险。文件包含与命令执行绕过则进一步考验对协议特性和系统特性的理解。Misc题中的流量分析与LSB隐写、逆向中的逻辑还原和古典密码特征识别,共同构成完整的安全技能图谱。这些技术广泛应用于渗透测试、应急响应和安全研究。本文以CTFshow菜狗杯为实战样本,

weixin_42530732的博客 191

C/C++笔记-构造makefile使用MOC程序及编译,链接

②:$(PROGRAM): $(OBJECTS):这个会先找在文件中找main.o Test.o moc_Test.o,如果找不到就在makefile下,看有没有对应的标签。背景是这样的构造一个Test类,使用了Q_OBJECT宏,和继承了QObject,也就是元对象,这时,makefile需要如何写。每一条命令在前一篇文章中已经说明了。

IT1995的博客 48万+

CTF入门实战:从菜狗杯看Web安全、密码学与Misc解题核心技巧

网络安全竞赛(CTF)是系统化培养安全攻防思维的重要途径,其核心在于掌握常见漏洞原理与自动化工具链的协同使用。在Web安全领域,SQL注入、文件包含等经典漏洞常通过自动化工具如sqlmap进行探测,而前端JavaScript代码审计则是发现逻辑漏洞的关键,例如分析混淆代码中的敏感信息泄露。密码学题目则侧重于编码识别与基础算法应用,如Base64、Hex编码转换以及异或(XOR)运算的加解密,其中异或因其可逆性在CTF中频繁出现,常用于已知明文攻击。杂项(Misc)题目则考验综合文件分析能力,涉及PNG文件结

weixin_33885676的博客 316

CMake参考手册(草稿)

CMakeList.txt 引言 cmake_minimum_required(VERSION XXX) project(xxx) add_executable(xx xxx) CMAKE_SOURCE_DIR --The root source directory CMAKE_CURRENT_SOURCE_DIR --The current source directory if using sub-projects and directories. PROJECT_SOURCE_DIR --The s

bigchen 21万+

CTFshow CRYPTO1/2/3入门精讲:编码识别、古典密码与异或逆向

在CTF密码学方向,Base64编码、凯撒密码和异或加密是入门阶段最常遇到的基础题型。Base64通过将每3字节拆分为4个6位组实现可逆编码,凯撒密码依赖字母频率分布进行暴力破解,异或运算则利用自反性实现加解密。掌握这些基础原理,能帮助安全从业者快速识别密文类型、选择攻击手段,在CTF竞赛、渗透测试中的编码绕过与简单加密逆向场景中高效解题。CTFshow的CRYPTO1/2/3正是围绕编码与加密区分、古典密码识别、简单数学逆向三类核心问题展开,是建立密码题解题直觉的经典入门训练。

weixin_34242331的博客 410

零基础入门CTF:100集系统教程带你掌握网络安全攻防实战

网络安全是当今数字世界的基石,其核心在于理解系统与应用的攻防原理。从基础的网络协议、编程语言到漏洞形成机制,安全技术旨在通过模拟攻击来发现和修复潜在风险,从而提升系统防御能力。CTF(Capture The Flag)竞赛作为网络安全领域的实战演练场,将复杂的攻防技术转化为具体的解题挑战,是验证与提升安全技能的绝佳途径。对于初学者而言,一套系统性的教程至关重要,它能有效整合碎片化的知识,降低学习门槛。本教程围绕Web安全、逆向工程、密码学等核心方向,结合Kali Linux、Burp Suite等【热词:实

weixin_33701294的博客 509

CTFShow古典密码学

从签到到凯撒密码,九道入门题一网打尽

Morilight的博客 538

CTF零基础入门全攻略:从题型拆解到刷题实战

网络安全竞赛CTF(Capture The Flag)以“夺旗”为核心,通过破解漏洞、分析数据、逆向算法等挑战,成为安全技术实战训练的高效载体。其基本原理是围绕Web安全、密码学、杂项、逆向工程等题型展开,要求选手在限时场景中提取特定格式的flag。对于零基础入门者,理解HTTP协议、掌握Python脚本、熟悉Kali Linux与Burp Suite等工具,结合ctfshow、BUUCTF等国内平台的梯度刷题,能够快速构建知识体系。CTF不仅提升漏洞分析与代码审计能力,更是信息安全领域求职与思维训练的重要

weixin_28568819的博客 223

CTFshow密码学入门:CRYPTO1-3核心解题思维与实操指南

编码与加密是网络安全的基础概念,编码用于数据转换,加密用于保密。理解其原理需掌握特征识别与数学运算。在CTF竞赛中,这些技能是解题关键,尤其密码学方向。通过Base64、凯撒密码、异或和RSA等基础题目,可以培养分析习惯。本文以CTFshow的CRYPTO1、2、3为例,拆解编码识别、古典密码破译和现代密码数学基础,帮助初学者建立核心解题思维。

weixin_34049948的博客 400

17、Mac应用的Spotlight与Quick Look集成技术解析

本文深入解析了Mac应用中Spotlight与Quick Look的集成技术,涵盖从Spotlight打开指定内容、Quick Look缩略图与预览生成、子项目配置到插件测试的完整流程。文章还总结了关键实现要点、性能优化策略及注意事项,并通过流程图和代码示例详细展示了技术实现路径,帮助开发者提升应用的专业性和用户体验。

h0i1j2k3l的博客 2270

一文详解心电图(ECG)监测原理

介绍心电图的监测原理,从心电信号产生、获取到心电图的基本组成

m0_50146396的博客 3309

ctfshow JiaJia-CP密码学入门:编码、异或与RSA题解

在网络安全竞赛中,CTF 密码学常被视为入门门槛较高的方向,核心并非复杂请求构造,而是对编码规则、数论原理与密码体制的识别能力。Base64、十六进制、古典密码、异或与 RSA 等知识点,构成了 CTF 密码题的基础图谱:先观察数据特征,再判断加密方式,最后选择攻击与脚本验证。掌握这些通用方法,不仅能提升 ctfshow 等平台刷题效率,也能迁移到漏洞分析、日志解码与安全开发中的数据处理场景。JiaJia-CP 系列以递进式题目串联编码识别、异或爆破和 RSA 参数攻击,适合作为 ctf入门 与 ctf密码

weixin_29322855的博客 301

告别虚拟机!用ZYNQ7000和PYNQ 2.6.0打造一个能实时识别人脸的“智能摄像头”

本文详细介绍了如何利用Xilinx ZYNQ7000开发板和PYNQ 2.6.0框架构建实时人脸识别系统。通过硬件加速和嵌入式开发技术,该系统实现了低延迟、低功耗的独立运行能力,适用于边缘计算和物联网应用。文章包含从环境搭建到核心功能实现的完整指南,并提供了性能优化和问题排查的实用技巧。

weixin_42543046的博客 393

CTFshow入门指南:Web安全与SQL注入实战

SQL注入作为Web安全的核心漏洞类型,其本质是用户输入被拼接为数据库查询语句导致的逻辑缺陷。通过构造特殊输入闭合原语句,攻击者可以绕过认证或获取敏感数据。在CTF竞赛和实际渗透测试中,掌握SQL注入与命令执行等基础漏洞的利用技术至关重要。CTFshow平台通过分级题目设计,帮助学习者从基础HTTP协议到高级反序列化漏洞逐步提升。针对无字母数字限制的命令执行场景,需要创造性运用环境变量截取等技巧,这与密码学中的替代密码思想异曲同工。系统化的训练方法和红蓝对抗模拟能有效提升实战能力。

weixin_34294649的博客 339

【系统分析师】高分论文:论软件开发方法及应用(数据中心CMDB 系统)

【摘要】本文以作者负责的"数据中心CMDB系统"建设项目为例,探讨了系统分析和建模方法在IT项目中的应用实践。项目基于ITIL框架,旨在整合分散的配置信息,构建统一CMDB平台。通过分析结构化、面向对象和构件化三种开发方法特点,项目最终采用结构化分析与V模型结合的方式,并融入面向对象设计理念。系统经过4个月开发后上线,通过增量迭代满足不同数据源接口需求,采用适配器模式提高兼容性。经过2个月试点运行和优化,系统已稳定运行并获得用户认可,为后续IT服务管理集成奠定了基础。项目实施使作者积累了

数据知道的博客 4300

LangChain .NET:C#开发者构建AI应用的RAG框架与实战指南

大语言模型(LLM)作为当前人工智能的核心技术,通过深度学习海量文本数据,掌握了强大的语言理解和生成能力。其原理基于Transformer架构,通过自注意力机制捕捉长距离依赖关系,从而实现对复杂语义的建模。这一技术价值在于能够将非结构化的自然语言转化为可计算、可推理的表示,为各类智能应用提供认知基础。在实际工程实践中,LLM常被应用于构建检索增强生成(RAG)系统和AI智能体(Agent)。RAG通过结合外部知识库检索与LLM生成,有效提升了问答的准确性和事实性,是构建企业知识库、智能客服等场景的关键技术。

weixin_42538175的博客 706

CTFSHOW平台Web安全与逆向工程入门实战指南

Web安全与逆向工程是网络安全领域的核心技能,其原理涉及对系统漏洞的识别与利用技术。在渗透测试中,SQL注入和命令执行等Web漏洞通过构造恶意payload实现未授权访问,而逆向工程则需要静态分析与动态调试技术还原程序逻辑。CTFSHOW平台作为优质的实战训练场,其基础题目涵盖Web安全、逆向工程等关键技术点,配合Burp Suite、IDA Pro等工具链使用,能有效提升漏洞挖掘能力。本文以CTFSHOW典型题目为例,详解命令执行绕过、SQL注入等高频考点,并分享逆向分析中PE文件解析与字符串查找等实用技

weixin_29314405的博客 295

AUTOSAR从入门到精通-【应用篇】基于AUTOSAR架构的混合动力电池 ECU 软件开发

由于严峻的环境污染和能源短缺问题,各国都在致力于发展新能源车,以达到节能排放的目的。在此背景下,12V启停系统由于成本较低廉、匹配方便,得到广泛应用。但是12V系统作为启停系统后存在许多问题,比如节能和减排效果有限,并且轻度混合动力系统的功率需求通常在10~15KW,在此电压条件下运行时,电池的电流会达到1000A,因此该方案行不通。高压混合动力系统(>110V)的节油效果好,但是成本很高,并且需要大功率的电机。48V混合动力系统比高压混合动力系统成本。

getusushu的博客 1491

新人必看 盘点知名CTF练习靶场

看雪 CTF 比赛历史悠久,从原 CrackMe 攻防大赛发展而来,采取线上 PK 方式,规则严格周全。题目领域广泛,涵盖 Windows、Android、iOS、Pwn、智能设备、Web 等。分为防守篇和攻击篇。防守方制作题目,根据被破解时间排名;攻击方攻击第一阶段的题目,根据破解时间和题目数排名。

小司机的奥拓 1407

图像修复的万能模型:用Instruct-IPT统一解决去雨、去雾、去模糊三大难题

从原理到实战,你已经掌握了Instruct-IPT的核心逻辑和使用方法。它不仅能一站式解决多种图像退化问题,还能通过文本指令灵活控制,是图像恢复领域的“多面手”。现在,不妨找几张有雨雪、雾霾、模糊问题的图像,用Instruct-IPT亲手试试效果。当你看到模糊的图像变得清晰,被雨雾遮挡的细节重新浮现时,你会真切感受到这项技术的魅力。后续还可以尝试调整文本指令的描述方式,看看模型的响应有什么变化——探索的过程,就是你技术进阶的最好见证。

m0_71589036的博客 227

【SpringBoot 4.x 第29节】Spring Security 7 入门:先理解认证和授权!

🏆 本文收录于 《滚雪球学 Spring Boot 4.x》 专栏。本专栏面向 有一定 Java 基础,但尚未系统学习 Spring Boot 的读者,采用“滚雪球式学习法”:先跑通、再理解、再重构、再上线,带你从第一个 Hello API 开始,逐步完成一个可部署、可监控、可扩展的后端项目。

**My Coding Family** 554

CTFshow-萌新 Writeup

这里写自定义目录标题萌新_密码1萌新_密码2萌新 密码3萌新 隐写2 萌新_密码1 密文: 53316C6B5A6A42684D3256695A44566A4E47526A4D5459774C5556375A6D49324D32566C4D4449354F4749345A6A526B4F48303D 提交格式:KEY{XXXXXXXXXXXXXX} hex转字符串 m="53316C6B5A6A42684D3256695A44566A4E47526A4D5459774C5556375A6D49324D3

Atkx's Blog 5348

搞定最强大模型Gemini学生订阅,白嫖一年,包教包会

白嫖现在最强大模型

BUG猿的博客 2万+

CTFshow入门指南:Web安全与SQL注入实战解析

SQL注入作为OWASP Top 10榜首的安全漏洞,其核心原理是通过构造特殊输入改变原始SQL查询逻辑。这种攻击方式在Web应用中尤为常见,攻击者利用未过滤的用户输入,实现数据库信息泄露甚至系统控制。从技术实现来看,主要涉及字符拼接、注释符滥用等基础SQL语法特性。在CTF竞赛和实际渗透测试中,掌握SQL注入技术具有极高价值,既能用于安全审计,也能帮助开发者理解防御措施。通过CTFshow等平台的场景化训练,学习者可以快速掌握数字型注入、布尔盲注、时间盲注等实战技巧,这些技能同样适用于企业级Web应用的安

weixin_33906657的博客 243

贝叶斯统计 [韦来生编]

贝叶斯(Bayes)统计是近几十年来迅速发展起来的数理统计的一个重要分支。贝叶斯方法与经典统计方法的主要不同之处是进行统计推断时除了利用样本信息外,还要利用参数的先验信息,因此可以提高统计推断或统计决策的效果。它在经济、金融、生物、医学、自然科学和社会科学等许多领域具有广泛的应用。贝叶斯方法的研究已渗透到了统计学的几乎所有领域。作者在给中国科学技术大学概率论与数理统计专业本科生开设的“数理统计”课程中有一章专门讲授“贝叶斯方法和统计决策理论”,近十年来也给中国科学技术大学概率统计专业研究生开设过几次“贝叶斯分析”课。本书是在对过去讲稿的内容作了适当的增减和调整的基础上完成的。  本书共分六章。第1章是绪论,介绍了贝叶斯统计的若干基本概念,同时对必要的数理统计的基础知识有重点地作了回顾。第二章介绍了确定先验分布的若干可供选择的方法。第三章介绍了几类常见统计模型参数的后验分布的主要结果和计算方法。第四章和第五章分别介绍了“贝叶斯统计推断”和“贝叶斯统计决策”的内容。第六章介绍了贝叶斯统计计算的若干方法,包括蒙特卡洛方法和马尔可夫链蒙特卡洛(MCMC)方法以及相关统计软件的简介。本书的每一章附右大量的例题和习题,书末附有常用的几个表格和部分习题解答供读者查用。  大约可在54学时内讲授本书的第1章至第六章的主要内容,教师可根据学时需要选讲本书第1章至第六章的部分内容。书中标“*”号的章节可略去不讲,留给读者作为阅读材料。第六章例题中的R代码和部分例题的数据文件等可从作者个人主页下载。  作者在编写本书的过程中参考了J.O.Berger教授的《统计决策论及贝叶斯分析》和茆诗松教授编写的《贝叶斯统计》等书中的一些内容,以及《贝叶斯分析》一书中由张伟平博士编写的有关贝叶斯统计计算的一些内容。在此表示衷心感谢。  本书编写准备过程中,中国科学技术大学统计与金融系的几个研究生帮助完成了本书部分中文的录入和排版,作者对他们的辛勤工作表示真诚的感谢。高等教育出版社为本书的出版给予了大力支持。在此一并致谢。

深度学习工具包 DeepLearningToolbox

深度学习工具包Deprecation notice.-----This toolbox is outdated and no longer maintained.There are much better tools available for deep learning than this toolbox, e.g. [Theano](http://deeplearning.net/software/theano/), [torch](http://torch.ch/) or [tensorflow](http://www.tensorflow.org/)I would suggest you use one of the tools mentioned above rather than use this toolbox.Best, Rasmus.DeepLearnToolbox================A Matlab toolbox for Deep Learning.Deep Learning is a new subfield of machine learning that focuses on learning deep hierarchical models of data.It is inspired by the human brain's apparent deep (layered, hierarchical) architecture.A good overview of the theory of Deep Learning theory is[Learning Deep Architectures for AI](http://www.iro.umontreal.ca/~bengioy/papers/ftml_book.pdf)For a more informal introduction, see the following videos by Geoffrey Hinton and Andrew Ng.* [The Next Generation of Neural Networks](http://www.youtube.com/watch?v=AyzOUbkUf3M) (Hinton, 2007)* [Recent Developments in Deep Learning](http://www.youtube.com/watch?v=VdIURAu1-aU) (Hinton, 2010)* [Unsupervised Feature Learning and Deep Learning](http://www.youtube.com/watch?v=ZmNOAtZIgIk) (Ng, 2011)If you use this toolbox in your research please cite [Prediction as a candidate for learning deep hierarchical models of data](http://www2.imm.dtu.dk/pubdb/views/publication_details.php?id=6284)```@MASTERSTHESIS\{IMM2012-06284, author = "R. B. Palm", title = "Prediction as a candidate for learning deep hierarchical models of data", year = "2012",}```Contact: rasmusbergpalm at gmail dot comDirectories included in the toolbox-----------------------------------`NN/` - A library for Feedforward Backpropagation Neural Networks`CNN/` - A library for Convolutional Neural Networks`DBN/` - A library for Deep Belief Networks`SAE/` - A library for Stacked Auto-Encoders`CAE/` - A library for Convolutional Auto-Encoders`util/` - Utility functions used by the libraries`data/` - Data used by the examples`tests/` - unit tests to verify toolbox is workingFor references on each library check REFS.mdSetup-----1. Download.2. addpath(genpath('DeepLearnToolbox'));Example: Deep Belief Network---------------------```matlabfunction test_example_DBNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit RBM and visualize its weightsrand('state',0)dbn.sizes = [100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);figure; visualize(dbn.rbm{1}.W'); % Visualize the RBM weights%% ex2 train a 100-100 hidden unit DBN and use its weights to initialize a NNrand('state',0)%train dbndbn.sizes = [100 100];opts.numepochs = 1;opts.batchsize = 100;opts.momentum = 0;opts.alpha = 1;dbn = dbnsetup(dbn, train_x, opts);dbn = dbntrain(dbn, train_x, opts);%unfold dbn to nnnn = dbnunfoldtonn(dbn, 10);nn.activation_function = 'sigm';%train nnopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.10, 'Too big error');```Example: Stacked Auto-Encoders---------------------```matlabfunction test_example_SAEload mnist_uint8;train_x = double(train_x)/255;test_x = double(test_x)/255;train_y = double(train_y);test_y = double(test_y);%% ex1 train a 100 hidden unit SDAE and use it to initialize a FFNN% Setup and train a stacked denoising autoencoder (SDAE)rand('state',0)sae = saesetup([784 100]);sae.ae{1}.activation_function = 'sigm';sae.ae{1}.learningRate = 1;sae.ae{1}.inputZeroMaskedFraction = 0.5;opts.numepochs = 1;opts.batchsize = 100;sae = saetrain(sae, train_x, opts);visualize(sae.ae{1}.W{1}(:,2:end)')% Use the SDAE to initialize a FFNNnn = nnsetup([784 100 10]);nn.activation_function = 'sigm';nn.learningRate = 1;nn.W{1} = sae.ae{1}.W{1};% Train the FFNNopts.numepochs = 1;opts.batchsize = 100;nn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.16, 'Too big error');```Example: Convolutional Neural Nets---------------------```matlabfunction test_example_CNNload mnist_uint8;train_x = double(reshape(train_x',28,28,60000))/255;test_x = double(reshape(test_x',28,28,10000))/255;train_y = double(train_y');test_y = double(test_y');%% ex1 Train a 6c-2s-12c-2s Convolutional neural network %will run 1 epoch in about 200 second and get around 11% error. %With 100 epochs you'll get around 1.2% errorrand('state',0)cnn.layers = { struct('type', 'i') %input layer struct('type', 'c', 'outputmaps', 6, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %sub sampling layer struct('type', 'c', 'outputmaps', 12, 'kernelsize', 5) %convolution layer struct('type', 's', 'scale', 2) %subsampling layer};cnn = cnnsetup(cnn, train_x, train_y);opts.alpha = 1;opts.batchsize = 50;opts.numepochs = 1;cnn = cnntrain(cnn, train_x, train_y, opts);[er, bad] = cnntest(cnn, test_x, test_y);%plot mean squared errorfigure; plot(cnn.rL);assert(er<0.12, 'Too big error');```Example: Neural Networks---------------------```matlabfunction test_example_NNload mnist_uint8;train_x = double(train_x) / 255;test_x = double(test_x) / 255;train_y = double(train_y);test_y = double(test_y);% normalize[train_x, mu, sigma] = zscore(train_x);test_x = normalize(test_x, mu, sigma);%% ex1 vanilla neural netrand('state',0)nn = nnsetup([784 100 10]);opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samples[nn, L] = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.08, 'Too big error');%% ex2 neural net with L2 weight decayrand('state',0)nn = nnsetup([784 100 10]);nn.weightPenaltyL2 = 1e-4; % L2 weight decayopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex3 neural net with dropoutrand('state',0)nn = nnsetup([784 100 10]);nn.dropoutFraction = 0.5; % Dropout fraction opts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex4 neural net with sigmoid activation functionrand('state',0)nn = nnsetup([784 100 10]);nn.activation_function = 'sigm'; % Sigmoid activation functionnn.learningRate = 1; % Sigm require a lower learning rateopts.numepochs = 1; % Number of full sweeps through dataopts.batchsize = 100; % Take a mean gradient step over this many samplesnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex5 plotting functionalityrand('state',0)nn = nnsetup([784 20 10]);opts.numepochs = 5; % Number of full sweeps through datann.output = 'softmax'; % use softmax outputopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, train_x, train_y, opts);[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');%% ex6 neural net with sigmoid activation and plotting of validation and training error% split training data into training and validation datavx = train_x(1:10000,:);tx = train_x(10001:end,:);vy = train_y(1:10000,:);ty = train_y(10001:end,:);rand('state',0)nn = nnsetup([784 20 10]); nn.output = 'softmax'; % use softmax outputopts.numepochs = 5; % Number of full sweeps through dataopts.batchsize = 1000; % Take a mean gradient step over this many samplesopts.plot = 1; % enable plottingnn = nntrain(nn, tx, ty, opts, vx, vy); % nntrain takes validation set as last two arguments (optionally)[er, bad] = nntest(nn, test_x, test_y);assert(er < 0.1, 'Too big error');```[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/rasmusbergpalm/deeplearntoolbox/trend.png)](https://bitdeli.com/free "Bitdeli Badge")

【建议收藏】CTF 网络安全夺旗赛刷题指南(2025 最新版):覆盖 BUUCTF/CTFshow 新题,附解题模板!

CTF(Capture The Flag)是一种网络安全竞赛形式,选手通过破解漏洞、逆向工程、密码学等手段获取目标服务器的“Flag”。

Button12138的博客 1198

Outlook Express 6 (OE6) for Win7/Win8/Win10

英文版 Outlook Express6.0, 兼容Win7/Win10/WinXP,解压就可用。

上一篇: CTF秀-密码学签到
下一篇: 新人入门Pwn从哪里开始
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值