为您推荐:
精华内容
最热下载
问答
  • 5星
    4.52MB zjzqxzhj 2021-02-01 15:44:50
  • 86.17MB qq_45869039 2020-09-27 17:16:23
  • CTF密码学题目初探(一)密码学总结(一)1.常见线索2.常见编码 密码学总结(一) 密码学一般可分为 古典密码学 和现代密码学。CTF中脑洞密码题(非现代加密方式)一般都是各种古典密码的变形。 1.常见线索 一般情况下...

    CTF密码学题目初探(一)

    密码学总结(一)

    密码学一般可分为 古典密码学现代密码学。CTF中脑洞密码题(非现代加密方式)一般都是各种古典密码的变形。

    1.常见线索

    一般情况下,题目中会给出一些线索。比如题目名称题目描述等。
    举例:题目名称为base64
    题目链接
    在这里插入图片描述
    举例:题目描述中写了“上面画着一个农妇在栅栏里面喂5只小鸡”…
    题目链接在这里插入图片描述

    2.常见编码

    1. base64/32/16编码
      加密解密网站链接
      原理:Base64是用于传输8Bit字节码的编码方式之一,基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64,所以每6个比特为一个单元,对应某个可打印字符。三个字节有24个比特,对应4个base64单元,即3个字节可表示4个可打印字符。它可用来作为电子邮件的传输编码。在base64中的可打印字符包括字母A-Z、a-z、数字0-9,共有62个字符。
      base32中只有大写字母(A-Z)和数字234567。
      base16中只有数字0-9以及大写字母ABCDEF。
      当看到**===**号的加密方式时,可以考虑base64。

    2. ASCII编码
      ASCII对照表
      举例:突然天上一道雷电gndk€rlqhmtkwwp}z
      比较一下"gndk"与"flag"的ASCII码,
      gndk的10进制的ASCII码分别是:103 110 100 107
      flag的10进制的ASCII码分别是 :102 108 97 103
      发现ASCII以此减少 1 2 3 4,所以以此类推解密得flag{lei_ci_jiami}

    3. Morse莫斯密码
      通过不同的排列顺序来表达不同的英文字母、数字和标点符号。
      莫斯密码翻译器
      莫斯密码包括5中状态
      1.点(.)
      2.划(-)
      3.每个字符间短的停顿(在点和划之间的停顿)
      4.每个词之间中等的停顿
      5.以及句子之间长的停顿
      11 111 010 000 0 1010 111 100 0 00 000 000 111 00 10 1 0 010 0 000 1 00 10 11011 111 010 000 0 1010 111 100 0 00 000 000 111 00 10 1 0 010 0 000 1 00 10 110
      (这里只用 0和1,所以应该是用01代替.、-。 那么到底是用1代表.还是用0代表.呢? 都试一下)

    4. Unicode编码
      Unicode在线编码解码链接
      原文本:You had me at hello
      编码后:\u0059\u006f\u0075\u0020\u0068\u0061\u0064\u0020\u006d\u0065\u0020\u0061\u0074\u0020\u0068\u0065\u006c\u006c\u006f

    5. XXencode编码
      XXencode在线编码解码
      原理:原理:XXencode将输入文本以每三个字节为单位进行编码。如果最后剩下的资料少于三个字节,不够的部分用零补齐。这三个字节共有24个bit,以6bit为单位分为4个组,每个组以十进制来表示所出现的数值只会落在0-63之间。以所对应值的位置字符代替。它所选择的可打印字符是:±0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz,一共64个字符。跟base64打印字符相比,就是uuencode多一个‘-’字符,少一个‘/’字符。但是,它里面字符顺序与base64完全不一样。
      (原文链接:https://blog.csdn.net/pdsu161530247/article/details/75667218)
      原文本:The quick brown fox jumps over the lazy dog
      编码后:hJ4VZ653pOKBf647mPrRi64NjS0-eRKpkQm-jRaJm65FcNG-gMLdt64FjNkc+

    6. UUencode编码
      UUencode在线编码解码
      原文本:You had me at hello
      编码后:366]U(&AA9"!M92!A="!H96QL;P``

    7. Quoted-printable编码解码
      编码解码链接
      原理:在邮件处理的各式编码中,很多编码的目的都是使七位字符的邮件协议体系可以传送八位的二进制文件、双字节语言等等。Quoted-Printable也是这样的编码,它的目的是帮助非ASCII编码的信件传输通过SMTP协议。
      Quoted-Printable编码是字符对应的编码,每个末编码的二进制字符被编码成三个字符,即一个等号和一个十六进制的数字,如"=AB"
      在这里插入图片描述

    8. URL编码
      url在线编码解码链接
      原理:URL地址(常说网址)规定了常用地数字,字母可以直接使用,另外一批作为特殊用户字符也可以直接用(/,:@等),剩下的其它所有字符必须通过%xx编码处理。
      注意:在CTF WEB题目中经常会用到URL编码,比如在url链接的后面补充一些字段以获取数据库中的信息。
      原链接:http://www.mzf.com/?login=123
      编码后:http%3a%2f%2fwww.mzf.com%2f%3flogin%3d123

    9. Escape/Unescape编码
      Escape/Unescape在线编码解码链接
      Escape/Unescape加密解码/编码解码,又叫%u编码。Escape编码/加密,就是字符对应UTF-16 ,16进制表示方式前面加%u。Unescape解码/解密,就是去掉"%u"后,将16进制字符还原。
      原文本:你好
      编码后:%u4f60%u597d

    10. HTML实体编码
      HTML在线编码解码链接
      HTML ISO-8859-1 参考手册

    11. 敲击码
      原理:敲击码(Tap code)是一种以非常简单的方式对文本信息进行编码的方法。因该编码对信息通过使用一系列的点击声音来编码而命名,敲击码是基于5×5方格波利比奥斯方阵来实现的,其中,K字母被整合到C中。
      敲击码表:在这里插入图片描述
      在这里插入图片描述

    12. md5加密解密
      MD5加密解密

    密文类型举例格式说明
    md5e10adc3949ba59abbe56e057f20f883e 49ba59abbe56e057标准md5,32位或16位
    md5(md5($pass))b80c9c5f86de74f0090fc1a88b27ef34第一次加密后,结果转换成小写,对结果再加密一次
    md5(md5(md5($pass)))e57941ff9000aedb44eb2fa13f6e3e3c第一次加密后,结果转换成小写,对结果再加密一次,结果转换成小写,对结果再加密一次
    MD5(MD5($pass))bb7ff6177ee612ef9dc6acd3a9ea7ea9第一次加密后,结果转换成大写,对结果再加密一次
    MD5(MD5(MD5($pass)))36d627bd562e83ab995fb1fdf59c95d9第一次加密后,结果转换成大写,对结果再加密一次,结果转换成大写,对结果再加密一次
    sha1f03e8a370aa8dc80f63a6d67401a692ae72fa530密文长度必须为40位
    md4c0a27f801162b8b862cd5f5a1a66e85a32位
    mysql29596332026fd206老MYSQL数据库用的,16位,且第1位和第7位必须为0-8
    mysql5b34c662f720236babfc1b3f75203a80e1009844a新版本MySql数据库用的
    md5( p a s s . pass. pass.salt)9393dc56f0c683b7bba9b3751d0f6a46:OTD6v4c8I3Zid2AL在密码后附加一个字符串再加密
    md5( s a l t . salt. salt.pass)5610604c157ef1d0fb33911542e5b06f:zg在密码前附加一个字符串再加密
    展开全文
    hzy_wsq 2020-06-15 17:52:09
  • 1.98MB m0_52957036 2020-02-03 11:50:33
  • CTF 密码学总结 题目类型总结: 简单密码类型: 复杂密码类型: 密码学脚本类总结: 单独的密文类型(优先使用ciphey工具) 多层传统加密混合: Bugku的密码学的入门题/.-:(摩斯密码、url编码、出人意料的...

    目录

    CTF 密码学总结

    题目类型总结:

    简单密码类型:

    复杂密码类型:

    密码学脚本类总结:

    单独的密文类型(优先使用ciphey工具)

    多层传统加密混合:

    Bugku的密码学的入门题/.-:(摩斯密码、url编码、出人意料的flag)

    攻防世界之混合编码:(base64解密、unicode解密、ASCII转字符脚本、传统base64解密、ASCII解密)

    单层传统加密:

    Bugku crypto之聪明的小羊:(题目描述暗示、栅栏密码)

    攻防世界之转轮机加密:(转轮机加密、)

    复杂加密类型

    ECC椭圆曲线加密:

    攻防世界 之easy_ECC:(ECC加密)

    python类型逻辑加密

    pyc文件反编译:

    攻防世界之easychallenge:(源代码修改逻辑解密、)

    传统密码类型解析

    凯撒密码(24个字母):

    摩斯密码(只有01(无规则)或.-,空格或/做分隔符):

    云影密码(01248):

    栅栏密码(分组数作密钥):

    培根密码(大小写的ABab,而且必须是5个一组,不是5个就考虑摩斯密码):

    与佛论禅编码,要加上佛曰:才能转换(BASE64类型转不了就ROT13一下)

    转轮机加密:

    URL编码规则:

    解密工具、脚本积累

    Ciphey工具:

    CTF-RSA-tool工具:

    RSA前景知识:

    RSA脚本工具使用说明:

    多组n,e,c在解题时长这个样子:

    一组n,e,c的题目样式:

    脚本类型示例:

    ECC加密:

    ECC脚本积累(解出最后的公钥和私钥即可):


    CTF 密码学总结

    出人意料的flag:

    指在题目中获取到了flag,但是这个flag可能长得不像flag,或者flag还要经过进一步的脑洞处理,而不是常规的解密处理。

    题目类型总结:

    题目描述暗示:

    指题目给出的描述中有解题的大方向思路,以及对解题过程中出现的一些疑惑点的解释。

    简单密码类型:

    摩斯密码:

    指解题中的密文涉及摩斯密码,摩斯密码的特征是以.-或01组成的,分隔符有空格或斜杠/。

    url编码:

    指解题中的密文涉及url编码,url编码的特征是使用 "%" 其后跟随两位的十六进制数来替换非 ASCII 字符。

    传统base64解密:

    指题目中密文是涉及base64加密,密文通常是4的倍数,基本元素是ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/和补充的'='

    unicode解密:

    指解题中密文涉及 unicode 解密,unicode现在已知的特征是ASCII(英文也是ASCII码)转unicode码时是 &# 前缀 +2 个 16 进制数,并用 ; 分隔。中文转unicode时是 \u + 4 个 16 进制数,中间没有间隔。

    举例:1234 ----->1234 牛逼-------->\u725b\u903c

    ASCII解密:

    指解题中密文涉及ASCII码,需要转成字符。ASCII共128个可显示字符,范围是0~127或0~7F。不同通常每个ASCII码的间隔依据出题者来定。

    栅栏密码:

    指解题中密文涉及栅栏密码,因为栅栏密码有传统的矩阵型和 W 型,所以需要自己辨认。根据题目给的 key 分段来逐个尝试。

    转轮机加密:

    指解密中密文涉及转轮机加密,转轮机密文的特点是等长的分好组的乱序字母,原理是转齿轮把一个字母换成另一个来拼成一句话,所以会有多组密钥,但是只有一组密文。

    格式举例,等长的分好组的字符串:

    ZWAXJGDLUBVIQHKYPNTCRMOSFE

    KPBELNACZDTRXMJQOYHGVSFUWI

    复杂密码类型:

    ECC加密:

    是一种建立公开密钥加密的算法,基于椭圆曲线数学的椭圆曲线密码学。

    密码学脚本类总结:

    ASCII转字符脚本:

    指解题中遇到长串ASCII码形式,需要转字符,但是一个个转太麻烦,又没有在线的长串ASCII码转字符网站。且给出的长串ASCII码的间隔依情况而定,如:/119/101/,这时需要自己根据对应间隔写出批量转换脚本。

    源代码修改逻辑解密:

    指解题中在有较完整源代码的情况下代码逻辑比较明朗,且可以逆向。这时需要充分利用有源代码的优势来在源代码中修改处逆向逻辑,不要自己从头到尾另写一份。

    单独的密文类型(优先使用ciphey工具)

    多层传统加密混合:

    Bugku的密码学的入门题/.-:(摩斯密码、url编码、出人意料的flag)

    摩斯密码是以.-或01组成的,分隔符有空格或斜杠/,所以直接扔去摩斯密码在线解密即可。

    网址:https://www.bejson.com/enc/morse/

    答案差不多了,却被%u7b和%u7d卡住了,猜想是{ }的url编码,{的url编码是%7B,}的url编码是%7D

    所以去掉u符号(这里u符号应该是什么十六进制之类的,我也不知道)

    直接得到flag:

    FLAG{D3FCBF17F9399504}

    结果全部要小写:

    flag{d3fcbf17f9399504}

    攻防世界之混合编码:(base64解密、unicode解密、ASCII转字符脚本、传统base64解密、ASCII解密)

    下载附件,打开,发现两个等号和19azA~Z的典型base64编码型,直接base64转换:

    转了一堆&#出来,根据以前的做题经验,猜unicode或hex:

    一开始用了十六进制来转,转了个四不像出来,后来发现转错了,unicode在线解码网址:

    http://www.jsons.cn/unicode/

    这三个数的看着像ASCII,因为题目暗示混合编码,直接转换看看:ASCCII表对照法:

    ASCII转字符脚本法:(这里因为string.split切片后返回的是列表,所以可以直接用索引获取。)

    import re

    r="/119/101/108/99/111/109/101/116/111/97/116/116/97/99/107/97/110/100/100/101/102/101/110/99/101/119/111/114/108/100"

    r=re.split("/",r)

    #print(r)

    flag=""

    for i in range(1,len(r)):

    flag+=chr(int(r[i]))

    print(flag)

    单层传统加密:

    Bugku crypto之聪明的小羊:(题目描述暗示、栅栏密码)

    好的,传统栅栏密码,下面是我以前的笔记:

    所谓栅栏密码,就是把要加密的明文分成N个一组,然后把每组的第1个字连起来,形成一段无规律的话。 不过栅栏密码本身有一个潜规则,就是组成栅栏的字母一般不会太多。(一般不超过30个,也就是一、两句话)

    传统栅栏密码(矩阵行列,密钥是行数):

    假如有一个字符串:123456789

    取字符串长度的因数进行分组,假如key=3

    1 2 3 \\分组情况,每三个数字一组,分为三组

    4 5 6

    7 8 9

    然后每一组依次取一个数字组成一个新字符串:147258369 \\加密完成的字符串

    解题:

    试一般的栅栏密码,取5为矩阵行数,得到" cyperrocaegireeol} eahfocec gnbip不正确,取5为矩阵列数,得到" cebgccfe en eohplprgecrayoii aoreg”,也不正确,除了常规的栅栏密码,还有

    由题目描述可知分两组:

    fa{fe13f590

    lg6d46d0d0}

    那么答案很明显了,上一个下一个即可得flag:

    flag{6fde4163df05d900}

    攻防世界之转轮机加密:(转轮机加密、)

    下载附件:

    好了,记住了,以后这个内容格式的就是转轮机加密了:

    原理就是转齿轮把一个字母换成另一个,直接上一个修改后的大佬脚本:

    rotor = [ #这里是要输入的转轮机原始字符串

    "ZWAXJGDLUBVIQHKYPNTCRMOSFE", "KPBELNACZDTRXMJQOYHGVSFUWI",

    "BDMAIZVRNSJUWFHTEQGYXPLOCK", "RPLNDVHGFCUKTEBSXQYIZMJWAO",

    "IHFRLABEUOTSGJVDKCPMNZQWXY", "AMKGHIWPNYCJBFZDRUSLOQXVET",

    "GWTHSPYBXIZULVKMRAFDCEONJQ", "NOZUTWDCVRJLXKISEFAPMYGHBQ",

    "XPLTDSRFHENYVUBMCQWAOIKZGJ", "UDNAJFBOWTGVRSCZQKELMXYIHP",

    "MNBVCXZQWERTPOIUYALSKDJFHG", "LVNCMXZPQOWEIURYTASBKJDFHG",

    "JZQAWSXCDERFVBGTYHNUMKILOP"

    ]

    cipher = "NFQKSEVOQOFNP" #这是要输入转轮机密文

    key = [2,3,7,5,13,12,9,1,8,10,4,11,6] #这是要输入转轮机密钥

    tmp_list=[]

    for i in range(0, len(rotor)):

    tmp=""

    k = key[i] - 1

    for j in range(0, len(rotor[k])):

    if cipher[i] == rotor[k][j]:

    if j == 0:

    tmp=rotor[k]

    break

    else:

    tmp=rotor[k][j:] + rotor[k][0:j]

    break

    tmp_list.append(tmp)

    # print(tmp_list)

    message_list = []

    for i in range(0, len(tmp_list[i])):

    tmp = ""

    for j in range(0, len(tmp_list)):

    tmp += tmp_list[j][i]

    message_list.append(tmp)

    print(message_list)

    def spread_list(lst):

    for item in lst:

    if isinstance(item,(list,tuple)):

    yield from spread_list(item)

    else:

    yield item

    pass

    if __name__ == '__main__':

    for i in spread_list(message_list):

    print("*"*25)

    print(i) #在多个输出中查找有语义的字符串即为flag内容

    复杂加密类型

    ECC椭圆曲线加密:

    攻防世界 之easy_ECC:(ECC加密)

    下载附件,打开:

    椭圆曲线ECC加密,没接触过,不懂原理,主要是找不到集成脚本,算了,浏览中发现一篇讲得透彻的博客:

    https://blog.csdn.net/weixin_30951231/article/details/95919343

    这里直接使用脚本:

    #!/usr/bin/env python3

    # -*- coding: UTF-8 -*-

    # @Time :2020/9/28

    # @Author :PeterJoin

    import collections

    import random

    EllipticCurve = collections.namedtuple('EllipticCurve', 'name p a b g n h')

    def banner():

    print(("""%s

    _____ ____ ____

    | ____/ ___/ ___|

    | _|| | | |

    | |__| |__| |___

    |_____\____\____|

    %s%s

    # Coded By PeterJoin -椭圆曲线加密(´・ω・)%s

    """ % ('\033[91m', '\033[0m', '\033[93m', '\033[0m')))

    curve = EllipticCurve(

    'secp256k1',

    # Field characteristic.

    p=int(input('p=')),

    # Curve coefficients.

    a=int(input('a=')),

    b=int(input('b=')),

    # Base point.

    g=(int(input('Gx=')),

    int(input('Gy='))),

    # Subgroup order.

    n=int(input('k=')),

    # Subgroup cofactor.

    h=1,

    )

    # Modular arithmetic ##########################################################

    def inverse_mod(k, p):

    """Returns the inverse of k modulo p.

    This function returns the only integer x such that (x * k) % p == 1.

    k must be non-zero and p must be a prime.

    """

    if k == 0:

    raise ZeroDivisionError('division by zero')

    if k < 0:

    # k ** -1 = p - (-k) ** -1 (mod p)

    return p - inverse_mod(-k, p)

    # Extended Euclidean algorithm.

    s, old_s = 0, 1

    t, old_t = 1, 0

    r, old_r = p, k

    while r != 0:

    quotient = old_r // r

    old_r, r = r, old_r - quotient * r

    old_s, s = s, old_s - quotient * s

    old_t, t = t, old_t - quotient * t

    gcd, x, y = old_r, old_s, old_t

    assert gcd == 1

    assert (k * x) % p == 1

    return x % p

    # Functions that work on curve points #########################################

    def is_on_curve(point):

    """Returns True if the given point lies on the elliptic curve."""

    if point is None:

    # None represents the point at infinity.

    return True

    x, y = point

    return (y * y - x * x * x - curve.a * x - curve.b) % curve.p == 0

    def point_neg(point):

    """Returns -point."""

    assert is_on_curve(point)

    if point is None:

    # -0 = 0

    return None

    x, y = point

    result = (x, -y % curve.p)

    assert is_on_curve(result)

    return result

    def point_add(point1, point2):

    """Returns the result of point1 + point2 according to the group law."""

    assert is_on_curve(point1)

    assert is_on_curve(point2)

    if point1 is None:

    # 0 + point2 = point2

    return point2

    if point2 is None:

    # point1 + 0 = point1

    return point1

    x1, y1 = point1

    x2, y2 = point2

    if x1 == x2 and y1 != y2:

    # point1 + (-point1) = 0

    return None

    if x1 == x2:

    # This is the case point1 == point2.

    m = (3 * x1 * x1 + curve.a) * inverse_mod(2 * y1, curve.p)

    else:

    # This is the case point1 != point2.

    m = (y1 - y2) * inverse_mod(x1 - x2, curve.p)

    x3 = m * m - x1 - x2

    y3 = y1 + m * (x3 - x1)

    result = (x3 % curve.p,

    -y3 % curve.p)

    assert is_on_curve(result)

    return result

    def scalar_mult(k, point):

    """Returns k * point computed using the double and point_add algorithm."""

    assert is_on_curve(point)

    if k < 0:

    # k * point = -k * (-point)

    return scalar_mult(-k, point_neg(point))

    result = None

    addend = point

    while k:

    if k & 1:

    # Add.

    result = point_add(result, addend)

    # Double.

    addend = point_add(addend, addend)

    k >>= 1

    assert is_on_curve(result)

    return result

    # Keypair generation and ECDHE ################################################

    def make_keypair():

    """Generates a random private-public key pair."""

    private_key = curve.n

    public_key = scalar_mult(private_key, curve.g)

    return private_key, public_key

    private_key, public_key = make_keypair()

    print("private key:", hex(private_key))

    print("public key: (0x{:x}, 0x{:x})".format(*public_key))

    if __name__ == '__main__':

    banner()

    make_keypair()

    运行之后照着输入题目附件给的参数即可:

    解出的x+y就是flag了,原理太难了,以后有机会再接触。

    python类型逻辑加密

    pyc文件反编译:

    攻防世界之easychallenge:(源代码修改逻辑解密、)

    下载附件,是pyc文件,于是要反编译,一开始看资料说用uncompyle6,我也不知道为什么我的老是报错,后来又找了个在线反编译,可以支持的Python版本比较多:

    https://tool.lu/pyc/

    反编译代码:

    #!/usr/bin/env python

    # visit https://tool.lu/pyc/ for more information

    import base64

    def encode1(ans):

    s = ""

    for i in ans:

    x = ord(i) ^ 36

    x = x + 25

    s += chr(x)

    return s

    def encode2(ans):

    s = ""

    for i in ans:

    x = ord(i) + 36

    x = x ^ 36

    s += chr(x)

    return s

    def encode3(ans):

    return base64.b32encode(ans)

    flag = " "

    print "Please Input your flag:"

    flag = raw_input()

    final = "UC7KOWVXWVNKNIC2XCXKHKK2W5NLBKNOUOSK3LNNVWW3E==="

    if encode3(encode2(encode1(flag))) == final:

    print "correct"

    else:

    print "wrong"

    本来是自己一层层改的,怎么加密就怎么逆过来解密,后来发现又犯了以前的错误,有源码就要用源码啊!!!

    直接在源码上修改即可:

    #!/usr/bin/env python

    # visit https://tool.lu/pyc/ for more information

    import base64

    def decode1(ans):

    s = ''

    for i in ans:

    x = ord(i) -25

    x = x ^ 36

    s += chr(x)

    return s

    def decode2(ans):

    s = ''

    for i in ans:

    x = i ^ 36

    x = x - 36

    s += chr(x)

    return s

    def decode3(ans):

    return base64.b32decode(ans)

    final = 'UC7KOWVXWVNKNIC2XCXKHKK2W5NLBKNOUOSK3LNNVWW3E==='

    print(decode1(decode2(decode3(final))) )

    传统密码类型解析

    凯撒密码(24个字母):

    特点:24个字母间的移动

    在密码学中,恺撒密码(英语:Caesar cipher),或称恺撒加密、恺撒变换、变换加密,是一种最简单且最广为人知的加密技术。它是一种替换加密的技术,明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。例如,当偏移量是3的时候,所有的字母A将被替换成D,B变成E,以此类推。

    加密就是明文向后移动展现出对应的密文。

    解密就是密文向前移动展现出对应的明文。

    明文字母表

    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

    摩斯密码(只有01(无规则)或.-,空格或/做分隔符):

    摩尔斯电码也被称作摩斯密码,是一种时通时断的信号代码,通过不同的排列顺序来表达不同的英文字母、数字和标点符号。它发明于1837年,是一种早期的数字化通信形式。不同于现代化的数字通讯,摩尔斯电码只使用零和一两种状态的二进制代码,它的代码包括五种:短促的点信号“・”,读“滴”(Di)保持一定时间的长信号“-”,读“嗒”(Da)表示点和划之间的停顿、每个词之间中等的停顿,以及句子之间长的停顿。

    摩斯电码:(格式要求:可用空格或单斜杠/来分隔摩斯电码,但只可用一种,不可混用)

    云影密码(01248):

    此密码运用了1248代码,因为本人才疏学法,问未发现有过使用的先例,因此暂归为原创密码。由于这个密码,我和片风云影初识,为了纪念,将其命名为“云影密码”。

    有了1,2,4,8这四个苘单的数字,你可以以加法表示出0~9任何个数字,例如0=28,7=124,9=18这样,再用1-26来表示A-Z,就可以用作密码了。为了不至于混乱,我个人引入了第五个数字0,来用作间隔,以遍免翻译错误,所以还可以称“01248密码”

    注意(3个及以上数字时):

    虽然是相加,但是可以在数字内不按顺序相加,如124可写成(12)4和1(24)结果分别是7和16,只要保证不大于26即可

    题目(总不超过26):

    12401011801180212011401804

    第一步分割:

    即124 、1、118、118、212、114、18、4

    第二步基本翻译:

    例如124可以表示7,也可以表示16(但不可能是34,因为不会超过26),所以可以放弃来翻译其他没有异议的,可得:124、a、s、s、w、o、18、d

    第三步推测得出明文:

    可以推测后面的18表示r,前面的为p最合适。

    所以最后明文:

    password(密码)

    栅栏密码(分组数作密钥):

    所谓栅栏密码,就是把要加密的明文分成N个一组,然后把每组的第1个字连起来,形成一段无规律的话。 不过栅栏密码本身有一个潜规则,就是组成栅栏的字母一般不会太多。(一般不超过30个,也就是一、两句话)

    传统栅栏密码(矩阵行列,密钥是行数):

    假如有一个字符串:123456789

    取字符串长度的因数进行分组,假如key=3

    1 2 3 \\分组情况,每三个数字一组,分为三组

    4 5 6

    7 8 9

    然后每一组依次取一个数字组成一个新字符串:147258369 \\加密完成的字符串

    解题:

    试一般的栅栏密码,取5为矩阵行数,得到" cyperrocaegireeol} eahfocec gnbip不正确,取5为矩阵列数,得到" cebgccfe en eohplprgecrayoii aoreg”,也不正确,除了常规的栅栏密码,还有一种w型的栅栏密码。

    w型的栅栏密码(第一行是Key数,后面排成w型横竖读取):

    同样一个字符串:123456789

    key=3

    1----5----9 \\让数字以W型组织,同样是三组,但每组的数量不一定相同

    -2--4-6--8

    --3----7--

    加密密文:159246837

    解题:

    题目提示:栅栏密码,密钥长度为5

    是将明文按照w型排列,并横(竖)向读取密文,其解密过程就是加密的逆过程,即将密文横(竖)向按一定规律排列后,以w型读取,对于此题,根据题目提示为以下5行。

    培根密码(大小写的ABab,而且必须是5个一组,不是5个就考虑摩斯密码):

    培根所用的密码是一种本质上用二进制数设计的,没有用通常的0和1来表示,而是采用a和b

    培根密码加密方式

    第一种方式:

    A aaaaa B aaaab C aaaba D aaabb E aabaa F aabab G aabba H aabbb I abaaa J abaab

    K ababa L ababb M abbaa N abbab O abbba P abbbb Q baaaa R baaab S baaba T baabb

    U babaa V babab W babba X babbb Y bbaaa Z bbaab

    第二种方式:

    a AAAAA g AABBA n ABBAA t BAABA

    b AAAAB h AABBB o ABBAB u-v BAABB

    c AAABA i-j ABAAA p ABBBA w BABAA

    d AAABB k ABAAB q ABBBB x BABAB

    e AABAA l ABABA r BAAAA y BABBA

    f AABAB m ABABB s BAAAB z BABBB

    举例

        例1、 baabaaabbbabaaabbaaaaaaaaabbabaaaabaaaaaabaaabaabaaaabaabbbaabbbaababb

                 baaba aabbb abaaa bbaaa aaaaa abbab aaaab aaaaa abaaa baaba  aaaba abbba abbba ababb

                    s           h         i           y         a         n         b         a        i           s          c         o          o        l 

    附加解密Python脚本如下:

    #!/usr/bin/python

    # -*- coding: utf-8 -*-

    import re

    alphabet = ['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']

    first_cipher = ["aaaaa","aaaab","aaaba","aaabb","aabaa","aabab","aabba","aabbb","abaaa","abaab","ababa","ababb","abbaa","abbab","abbba","abbbb","baaaa","baaab","baaba","baabb","babaa","babab","babba","babbb","bbaaa","bbaab"]

    second_cipher = ["aaaaa","aaaab","aaaba","aaabb","aabaa","aabab","aabba","aabbb","abaaa","abaaa","abaab","ababa","ababb","abbaa","abbab","abbba","abbbb","baaaa","baaab","baaba","baabb","baabb","babaa","babab","babba","babbb"]

    def encode():

    string = raw_input("please input string to encode:\n") #这里接收要加密的字符串

    e_string1 = ""

    e_string2 = ""

    for index in string:

    for i in range(0,26):

    if index == alphabet[i]:

    e_string1 += first_cipher[i]

    e_string2 += second_cipher[i]

    break

    print "first encode method result is:\n"+e_string1

    print "second encode method result is:\n"+e_string2

    return

    def decode():

    e_string = raw_input("please input string to decode:\n") #这里接收要解密的字符串

    e_array = re.findall(".{5}",e_string)

    d_string1 = ""

    d_string2 = ""

    for index in e_array:

    for i in range(0,26):

    if index == first_cipher[i]:

    d_string1 += alphabet[i]

    if index == second_cipher[i]:

    d_string2 += alphabet[i]

    print "first decode method result is:\n"+d_string1

    print "second decode method result is:\n"+d_string2

    return

    if __name__ == '__main__':

    while True:

    print "\t*******Bacon Encode_Decode System*******"

    print "input should be lowercase,cipher just include a b"

    print "1.encode\n2.decode\n3.exit"

    s_number = raw_input("please input number to choose\n")

    if s_number == "1":

    encode()

    raw_input()

    elif s_number == "2":

    decode()

    raw_input()

    elif s_number == "3":

    break

    else:

    continue

    与佛论禅编码,要加上佛曰:才能转换(BASE64类型转不了就ROT13一下)

    网址:

    与佛论禅

    题目文字:

    夜哆悉諳多苦奢陀奢諦冥神哆盧穆皤三侄三即諸諳即冥迦冥隸數顛耶迦奢若吉怯陀諳怖奢智侄諸若奢數菩奢集遠俱老竟寫明奢若梵等盧皤豆蒙密離怯婆皤礙他哆提哆多缽以南哆心曰姪罰蒙呐神。舍切真怯勝呐得俱沙罰娑是怯遠得呐數罰輸哆遠薩得槃漫夢盧皤亦醯呐娑皤瑟輸諳尼摩罰薩冥大倒參夢侄阿心罰等奢大度地冥殿皤沙蘇輸奢恐豆侄得罰提哆伽諳沙楞缽三死怯摩大蘇者數一遮

    转换后的

    MzkuM3gvMUAwnzuvn3cgozMlMTuvqzAenJchMUAeqzWenzEmLJW9

    的确是BASE64类型,但是直接BASE64是转换不出来的,还要先ROT13一下,可以算是一个小混淆,长见识了。

    转轮机加密:

    特点是等长的分好组的乱序字母,原理是转齿轮把一个字母换成另一个来拼成一句话。

    格式是这样的:

    脚本解题积累:

    rotor = [ #这里是要输入的转轮机原始字符串

    "ZWAXJGDLUBVIQHKYPNTCRMOSFE", "KPBELNACZDTRXMJQOYHGVSFUWI",

    "BDMAIZVRNSJUWFHTEQGYXPLOCK", "RPLNDVHGFCUKTEBSXQYIZMJWAO",

    "IHFRLABEUOTSGJVDKCPMNZQWXY", "AMKGHIWPNYCJBFZDRUSLOQXVET",

    "GWTHSPYBXIZULVKMRAFDCEONJQ", "NOZUTWDCVRJLXKISEFAPMYGHBQ",

    "XPLTDSRFHENYVUBMCQWAOIKZGJ", "UDNAJFBOWTGVRSCZQKELMXYIHP",

    "MNBVCXZQWERTPOIUYALSKDJFHG", "LVNCMXZPQOWEIURYTASBKJDFHG",

    "JZQAWSXCDERFVBGTYHNUMKILOP"

    ]

    cipher = "NFQKSEVOQOFNP" #这是要输入转轮机密文

    key = [2,3,7,5,13,12,9,1,8,10,4,11,6] #这是要输入转轮机密钥

    tmp_list=[]

    for i in range(0, len(rotor)):

    tmp=""

    k = key[i] - 1

    for j in range(0, len(rotor[k])):

    if cipher[i] == rotor[k][j]:

    if j == 0:

    tmp=rotor[k]

    break

    else:

    tmp=rotor[k][j:] + rotor[k][0:j]

    break

    tmp_list.append(tmp)

    # print(tmp_list)

    message_list = []

    for i in range(0, len(tmp_list[i])):

    tmp = ""

    for j in range(0, len(tmp_list)):

    tmp += tmp_list[j][i]

    message_list.append(tmp)

    print(message_list)

    def spread_list(lst):

    for item in lst:

    if isinstance(item,(list,tuple)):

    yield from spread_list(item)

    else:

    yield item

    pass

    if __name__ == '__main__':

    for i in spread_list(message_list):

    print("*"*25)

    print(i) #在多个输出中查找有语义的字符串即为flag内容

    URL编码规则:

    URL 编码使用 "%" 其后跟随两位的十六进制数来替换非 ASCII 字符。

    ASCII Value

    URL-encode

    ASCII Value

    URL-encode

    ASCII Value

    URL-encode

    ASCII Value

    URL-encode

    ASCII Value

    URL-encode

    ASCII Value

    URL-encode

    NULL结束符

    %00

    0

    %30

    `

    %60

    %90

    À

    %c0

    ð

    %f0

    %01

    1

    %31

    a

    %61

    %91

    Á

    %c1

    ñ

    %f1

    %02

    2

    %32

    b

    %62

    %92

    Â

    %c2

    ò

    %f2

    %03

    3

    %33

    c

    %63

    %93

    Ã

    %c3

    ó

    %f3

    %04

    4

    %34

    d

    %64

    %94

    Ä

    %c4

    ô

    %f4

    %05

    5

    %35

    e

    %65

    %95

    Å

    %c5

    õ

    %f5

    %06

    6

    %36

    f

    %66

    %96

    Æ

    %c6

    ö

    %f6

    %07

    7

    %37

    g

    %67

    %97

    Ç

    %c7

    ÷

    %f7

    backspace

    %08

    8

    %38

    h

    %68

    ˜

    %98

    È

    %c8

    ø

    %f8

    tab

    %09

    9

    %39

    i

    %69

    %99

    É

    %c9

    ù

    %f9

    换行符

    %0a

    :

    %3a

    j

    %6a

    š

    %9a

    Ê

    %ca

    ú

    %fa

    %0b

    ;

    %3b

    k

    %6b

    %9b

    Ë

    %cb

    û

    %fb

    %0c

    <

    %3c

    l

    %6c

    œ

    %9c

    Ì

    %cc

    ü

    %fc

    c return

    %0d

    =

    %3d

    m

    %6d

    %9d

    Í

    %cd

    ý

    %fd

    %0e

    >

    %3e

    n

    %6e

    ž

    %9e

    Î

    %ce

    þ

    %fe

    %0f

    ?

    %3f

    o

    %6f

    Ÿ

    %9f

    Ï

    %cf

    ÿ

    %ff

    %10

    @

    %40

    p

    %70

    %a0

    Ð

    %d0

    %11

    A

    %41

    q

    %71

    ¡

    %a1

    Ñ

    %d1

    %12

    B

    %42

    r

    %72

    ¢

    %a2

    Ò

    %d2

    %13

    C

    %43

    s

    %73

    £

    %a3

    Ó

    %d3

    %14

    D

    %44

    t

    %74

    %a4

    Ô

    %d4

    %15

    E

    %45

    u

    %75

    ¥

    %a5

    Õ

    %d5

    %16

    F

    %46

    v

    %76

    |

    %a6

    Ö

    %d6

    %17

    G

    %47

    w

    %77

    §

    %a7

    %d7

    %18

    H

    %48

    x

    %78

    ¨

    %a8

    Ø

    %d8

    %19

    I

    %49

    y

    %79

    ©

    %a9

    Ù

    %d9

    %1a

    J

    %4a

    z

    %7a

    ª

    %aa

    Ú

    %da

    %1b

    K

    %4b

    {

    %7b

    «

    %ab

    Û

    %db

    %1c

    L

    %4c

    |

    %7c

    ¬

    %ac

    Ü

    %dc

    %1d

    M

    %4d

    }

    %7d

    ¯

    %ad

    Ý

    %dd

    %1e

    N

    %4e

    ~

    %7e

    ®

    %ae

    Þ

    %de

    %1f

    O

    %4f

    %7f

    ¯

    %af

    ß

    %df

    空格

    %20

    P

    %50

    %80

    °

    %b0

    à

    %e0

    !

    %21

    Q

    %51

    %81

    ±

    %b1

    á

    %e1

    "

    %22

    R

    %52

    %82

    ²

    %b2

    â

    %e2

    #

    %23

    S

    %53

    ƒ

    %83

    ³

    %b3

    ã

    %e3

    $

    %24

    T

    %54

    %84

    ´

    %b4

    ä

    %e4

    %

    %25

    U

    %55

    %85

    µ

    %b5

    å

    %e5

    &

    %26

    V

    %56

    %86

    %b6

    æ

    %e6

    '

    %27

    W

    %57

    %87

    ·

    %b7

    ç

    %e7

    (

    %28

    X

    %58

    ˆ

    %88

    ¸

    %b8

    è

    %e8

    )

    %29

    Y

    %59

    %89

    ¹

    %b9

    é

    %e9

    *

    %2a

    Z

    %5a

    Š

    %8a

    º

    %ba

    ê

    %ea

    +

    %2b

    [

    %5b

    %8b

    »

    %bb

    ë

    %eb

    ,

    %2c

    \

    %5c

    Œ

    %8c

    ¼

    %bc

    ì

    %ec

    -

    %2d

    ]

    %5d

    %8d

    ½

    %bd

    í

    %ed

    .

    %2e

    ^

    %5e

    Ž

    %8e

    ¾

    %be

    î

    %ee

    /

    %2f

    _

    %5f

    %8f

    ¿

    %bf

    ï

    %ef

    解密工具、脚本积累

    Ciphey工具:

    Ciphey 是一个使用自然语言处理和人工智能的全自动解密/解码/破解工具,只需要输入加密文本,它就能给你返回解密文本。

    Ciphey 基本使用:

    文件输入:

    ciphey -f encrypted.txt

    # 或

    python -m ciphey -f encrypted.txt

    不规范的方法:

    ciphey -- "Encrypted input"

    # 或

    python -m ciphey -- "Encrypted input"

    正常方式:

    ciphey -t "Encrypted input"

    # 或

    python -m ciphey -t "Encrypted input"

    要去除进度条、概率表和所有噪音,请使用安静模式:

    ciphey -t "encrypted text here" -q

    Ciphey 支持解密的密文和编码多达51种,下面列出一些基本的选项基本密码:

    Caesar Cipher

    ROT47 (up to ROT94 with the ROT47 alphabet)

    ASCII shift (up to ROT127 with the full ASCII alphabet)

    Vigenère Cipher

    Affine Cipher

    Binary Substitution Cipher (XY-Cipher)

    Baconian Cipher (both variants)

    Soundex

    Transposition Cipher

    Pig Latin

    现代密码学:

    Repeating-key XOR

    Single XOR

    编码:

    Base32

    Base64

    Z85 (release candidate stage)

    Base65536 (release candidate stage)

    ASCII

    Reversed text

    Morse Code

    DNA codons (release candidate stage)

    Atbash

    Standard Galactic Alphabet (aka Minecraft Enchanting Language)

    Leetspeak

    Baudot ITA2

    URL encoding

    SMS Multi-tap

    DMTF (release candidate stage)

    UUencode

    Braille (Grade 1)

    Ciphey 的功能不仅于本文介绍的这些,本文所介绍的只是冰山一角,它还可以添加属于你自己的解码器:

    https://github.com/Ciphey/Ciphey/wiki/Adding-your-own-ciphers

    CTF-RSA-tool工具:

    RSA前景知识:

    RSA公开密钥密码体制是一种使用不同的加密密钥与解密密钥,“由已知加密密钥推导出解密密钥在计算上是不可行的”密码体制 。

    在公开密钥密码体制中,加密密钥(即公开密钥)PK是公开信息,而解密密钥(即秘密密钥)SK是需要保密的。加密算法E和解密算法D也都是公开的。虽然解密密钥SK是由公开密钥PK决定的,但却不能根据PK计算出SK [2] 。

    RSA公开密钥密码体制的原理是:根据数论,寻求两个大素数比较简单,而将它们的乘积进行因式分解却极其困难,因此可以将乘积公开作为加密密钥 [4] 。

    RSA脚本工具使用说明:

    usage: solve.py [-h]

    用法:solve.py[-h] (--decrypt DECRYPT | -c DECRYPT_INT | --private | -i INPUT | -g)

    [--createpub] [-o OUTPUT] [--dumpkey] [--enc2dec ENC2DEC] [-k KEY] [-N N] [-e E] [-d D] [-p P] [-q Q] [--KHBFA KHBFA][--pbits PBITS]

    [-v]

    It helps CTFer to get first blood of RSA-base CTF problems 它有助于CTFer获得RSA基础CTF问题的第一滴血

    -v, --verbose print details 详细的打印细节

    optional arguments:可选参数(注意!!!这里之间只可选一个,且必选一个!):

    -h, --help show this help message and exit --帮助显示此帮助消息并退出

    --decrypt DECRYPT decrypt a file, usually like "flag.enc" 解密文件,通常类似于“flag.enc”

    (通常搭配k的.pem或.pub一起使用)

    -c DECRYPT_INT,

    --decrypt_int DECRYPT_INT 解密长整形数

    --private Print private key if recovered 打印私钥(如果已解密)

    -i INPUT input a file with all necessary parameters (see examples/input_example.txt)

    输入包含所有必要参数的文件(请参见示例/输入(示例.txt)

    -g, --gadget Use some gadgets to pre-process your data first 使用一些小工具先预处理数据

    some gadgets:一些小工具预处理数据(全部可选):

    --createpub Take N and e and output to file specified by "-o" or just print it

    获取N和e并输出到由“-o”指定的文件或者直接打印出来就行了

    -o OUTPUT, --output OUTPUT 输出 Specify the output file path in --createpub mode.

    在--createpub模式下指定输出文件路径。

    --dumpkey Just print the RSA variables from a key - n,e,d,p,q

    只打印一个key-n、e、d、p、q中的RSA变量

    --enc2dec ENC2DEC get cipher (in decimalism) from a encrypted file

    从加密文件中获取密码(十进制)

    the RSA variables:RSA变量:Specify the variables whatever you got指定您得到的变量:(全部可选,实验中发现输入时只能用N、e参数进行命令行输入)

    -k KEY, pem file, usually like ".pub" or ".pem", and it begins with "-----BEGIN"

    pem文件,通常类似于“.pub”或“.pem”,并以“-----BEGIN”开始

    -N N the modulus 模量

    -e E the public exponent 公共指数

    -d D the private exponent 私人指数

    -p P one factor of modulus 模量的一个因子

    -q Q one factor of modulus 模量的一个因子

    extra variables:额外变量:Used in some special methods 在一些特殊的方法中使用:

    --KHBFA KHBFA use Known High Bits Factor Attack, this specify the High Bits of factor

    使用已知的高位因子攻击,这指定因子高位

    --pbits PBITS customize the bits lenth of factor, default is half of n`s bits lenth

    自定义因子的位长度,默认值为n's比特长度

    多组n,e,c在解题时长这个样子:

    可以看到特征真的就是多个n,e,c,甚至还有d,且不管这里的n,e,c是大还是小,长还是短,都列入多组n,e,c类型里。

    一组n,e,c的题目样式:

    从这里可以看到一组,n,e,c里面甚至可以没有c,这里的n,e,c也不管大小,长短,这里最后一个hbop的解题要用到前面说得sagemath,这里暂且不说。

    脚本类型示例:

    补充:

    单个n,e,c,q,p,的时候最好用单个参数输入的方式,不要用文本读取的方式,因为文本读取的时候DEBUG显示的十六进制的d有时并不是我们想要的

    # 只需要一组密钥的

    # wiener_attack

    python2 solve.py --verbose -i examples/wiener_attack.txt

    # 或者通过命令行,只要指定对应参数就行了

    python2 solve.py --verbose --private -N 460657813884289609896372056585544172485318117026246263899744329237492701820627219556007788200590119136173895989001382151536006853823326382892363143604314518686388786002989248800814861248595075326277099645338694977097459168530898776007293695728101976069423971696524237755227187061418202849911479124793990722597 -e 354611102441307572056572181827925899198345350228753730931089393275463916544456626894245415096107834465778409532373187125318554614722599301791528916212839368121066035541008808261534500586023652767712271625785204280964688004680328300124849680477105302519377370092578107827116821391826210972320377614967547827619

    # factordb.com

    python2 solve.py --verbose -k examples/jarvis_oj_mediumRSA/pubkey.pem --decrypt examples/jarvis_oj_mediumRSA/flag.enc

    # Boneh and Durfee attack

    # TODO: get an example public key solvable by boneh_durfee but not wiener

    # small q attack

    python2 solve.py --verbose --private -k examples/small_q.pub

    # 2017强网杯线上赛 RSA 费马分解(p&q相近时)

    python2 solve.py --verbose -i examples/closed_p_q.txt

    # Common factor between ciphertext and modulus attack

    python2 solve.py --verbose -k examples/common_factor.pub --decrypt examples/common_factor.cipher

    # small e

    python2 solve.py --verbose -k examples/small_exponent.pub --decrypt examples/small_exponent.cipher

    # rabin method when e == 2

    python2 solve.py --verbose -k examples/jarvis_oj_hardRSA/pubkey.pem --decrypt examples/jarvis_oj_hardRSA/flag.enc

    # Small fractions method when p/q is close to a small fraction

    python2 solve.py --verbose -k examples/smallfraction.pub --private

    # Known High Bits Factor Attack

    python2 solve.py --verbose -i examples/KnownHighBitsFactorAttack.txt

    # 需要多组密钥的

    # 第三届上海市大学生网络安全大赛--rrrsa d泄漏攻击

    python2 solve.py --verbose -i examples/d_leak.txt

    # 模不互素

    python2 solve.py --verbose -i examples/share_factor.txt

    # 共模攻击

    python2 solve.py --verbose -i examples/share_N.txt

    # Basic Broadcast Attack(低加密指数广播攻击)

    python2 solve.py --verbose -i examples/Basic_Broadcast_Attack.txt

    ECC加密:

    介绍:

    椭圆曲线密码学(英语:Elliptic curve cryptography,缩写为 ECC),一种建立公开密钥加密的算法,基于椭圆曲线数学。

    ECC的主要优势是在某些情况下它比其他的方法使用更小的密钥——比如RSA加密算法——提供相当的或更高等级的安全。ECC的另一个优势是可以定义群之间的双线性映射,基于Weil对或是Tate对;双线性映射已经在密码学中发现了大量的应用,例如基于身份的加密。其缺点是同长度密钥下加密和解密操作的实现比其他机制花费的时间长 [1] ,但由于可以使用更短的密钥达到同级的安全程度,所以同级安全程度下速度相对更快。一般认为160比特的椭圆曲线密钥提供的安全强度与1024比特RSA密钥相当。

    关键总结:

    设私钥、公钥分别为k、K,即K = kG,其中G为G点。

      公钥加密:

      选择随机数r,将消息M生成密文C,该密文是一个点对,即:

      C = {rG, M+rK},其中K为公钥

      私钥解密:

      M + rK - k(rG) = M + r(kG) - k(rG) = M

      其中k、K分别为私钥、公钥。

    题目样式举例:

    ECC脚本积累(解出最后的公钥和私钥即可):

    import collections

    import random

    EllipticCurve = collections.namedtuple('EllipticCurve', 'name p a b g n h')

    curve = EllipticCurve(

    'secp256k1',

    # Field characteristic.

    p=int(input('p=')),

    # Curve coefficients.

    a=int(input('a=')),

    b=int(input('b=')),

    # Base point.

    g=(int(input('Gx=')),

    int(input('Gy='))),

    # Subgroup order.

    n=int(input('k=')),

    # Subgroup cofactor.

    h=1,

    )

    # Modular arithmetic ##########################################################

    def inverse_mod(k, p):

    """Returns the inverse of k modulo p.

    This function returns the only integer x such that (x * k) % p == 1.

    k must be non-zero and p must be a prime.

    """

    if k == 0:

    raise ZeroDivisionError('division by zero')

    if k < 0:

    # k ** -1 = p - (-k) ** -1 (mod p)

    return p - inverse_mod(-k, p)

    # Extended Euclidean algorithm.

    s, old_s = 0, 1

    t, old_t = 1, 0

    r, old_r = p, k

    while r != 0:

    quotient = old_r // r

    old_r, r = r, old_r - quotient * r

    old_s, s = s, old_s - quotient * s

    old_t, t = t, old_t - quotient * t

    gcd, x, y = old_r, old_s, old_t

    assert gcd == 1

    assert (k * x) % p == 1

    return x % p

    # Functions that work on curve points #########################################

    def is_on_curve(point):

    """Returns True if the given point lies on the elliptic curve."""

    if point is None:

    # None represents the point at infinity.

    return True

    x, y = point

    return (y * y - x * x * x - curve.a * x - curve.b) % curve.p == 0

    def point_neg(point):

    """Returns -point."""

    assert is_on_curve(point)

    if point is None:

    # -0 = 0

    return None

    x, y = point

    result = (x, -y % curve.p)

    assert is_on_curve(result)

    return result

    def point_add(point1, point2):

    """Returns the result of point1 + point2 according to the group law."""

    assert is_on_curve(point1)

    assert is_on_curve(point2)

    if point1 is None:

    # 0 + point2 = point2

    return point2

    if point2 is None:

    # point1 + 0 = point1

    return point1

    x1, y1 = point1

    x2, y2 = point2

    if x1 == x2 and y1 != y2:

    # point1 + (-point1) = 0

    return None

    if x1 == x2:

    # This is the case point1 == point2.

    m = (3 * x1 * x1 + curve.a) * inverse_mod(2 * y1, curve.p)

    else:

    # This is the case point1 != point2.

    m = (y1 - y2) * inverse_mod(x1 - x2, curve.p)

    x3 = m * m - x1 - x2

    y3 = y1 + m * (x3 - x1)

    result = (x3 % curve.p,

    -y3 % curve.p)

    assert is_on_curve(result)

    return result

    def scalar_mult(k, point):

    """Returns k * point computed using the double and point_add algorithm."""

    assert is_on_curve(point)

    if k < 0:

    # k * point = -k * (-point)

    return scalar_mult(-k, point_neg(point))

    result = None

    addend = point

    while k:

    if k & 1:

    # Add.

    result = point_add(result, addend)

    # Double.

    addend = point_add(addend, addend)

    k >>= 1

    assert is_on_curve(result)

    return result

    # Keypair generation and ECDHE ################################################

    def make_keypair():

    """Generates a random private-public key pair."""

    private_key = curve.n

    public_key = scalar_mult(private_key, curve.g)

    return private_key, public_key

    private_key, public_key = make_keypair()

    print("private key:", hex(private_key))

    print("public key: (0x{:x}, 0x{:x})".format(*public_key))

    展开全文
    xiao__1bai 2021-11-01 21:22:26
  • CTF 密码学入门 这几天看了一些密码学的题,觉得水特别深,加密解密的方法太多了,对于萌新来说,入门不容易。 下面说几种这几天做到的,常见的加密解密方式: 1. base64 如: TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG...

    CTF 密码学入门

    这几天看了一些密码学的题,觉得水特别深,加密解密的方法太多了,对于萌新来说,入门不容易。
    下面说几种这几天做到的,常见的加密解密方式:
    1.
    base64/32/16
    如:
    TWFuIGlzIGRpc3Rpbmd1aXNoZWQsIG5vdCBvbmx5IGJ5IGhpcyByZWFzb24sIGJ1dCBieSB0aGlz
    IHNpbmd1bGFyIHBhc3Npb24gZnJvbSBvdGhlciBhbmltYWxzLCB3aGljaCBpcyBhIGx1c3Qgb2Yg
    dGhlIG1pbmQsIHRoYXQgYnkgYSBwZXJzZXZlcmFuY2Ugb2YgZGVsaWdodCBpbiB0aGUgY29udGlu
    dWVkIGFuZCBpbmRlZmF0aWdhYmxlIGdlbmVyYXRpb24gb2Yga25vd2xlZGdlLCBleGNlZWRzIHRo
    ZSBzaG9ydCB2ZWhlbWVuY2Ugb2YgYW55IGNhcm5hbCBwbGVhc3VyZS4=
    (等号!!等号是重要标志以及符号+, /, =等)
    如果最后剩下两个输入数据,在编码结果后加1个“=”;如果最后剩下一个输入数据,编码结果后加2个“=”;如果没有剩下任何数据,就什么都不要加,这样才可以保证资料还原的正确性。
    在base家族中有小写的是base64,没有189的是base32,“=”是凑位数的!!!
    以及base密码变种太多,所以必要时可以直接quipqiup解密即可

    Morse密码
    如:
    .- -.-- …–.- -… . …–.- … .- …- . …–.- .- -. — - … . .-. …–.- -… . -.-. — -… . … … … … .- .- .- .- .- -… .- .- -… -… -… .- .- -… -… .- .- .- .- .- .- .- .- -… .- .- -… .- -… .- .- .- .- .- .- .- -… -… .- -… .- .- .- -… -… .- .- .- -… -… .- .- -… .- .- .- .- -… .- -… .- .- -… .- .- .- -… -… .- -… .- .- .- -… .- .- .- -… .- .- -… .- -… -… .- .- -… -… -… .- -… .- .- .- -… .- -… .- -… -… .- .- .- -… -… .- -… .- .- .- -… .- .- -… .- .- -… .- .- .- .- -… -… .- -… -… .- .- -… -… .- .- -… .- .- -… .- .- .- -… .- .- -… .- .- -… .- .- -… .- -… .- .- -… -… .- -… .- .- .- .- -… -… .- -… .- .- -… -… .-
    通常是由0101……或者如上图所示的.-.-…-为标志

    培根密码
    了解不多也不深。
    大致是做题时看见了一回。
    这个密码很神奇,大致上是AB来表示
    如:
    AAAAABAABBBAABBAAAAAAAABAABABAAAAAAABBABAAABBAAABBAABAAAABABAABAAABBABAAABAAABAABABBAABBBABAAABABABBAAABBABAAABAABAABAAAABBABBAABBAABAABAAABAABAABAABABAABBABAAAABBABAABBA等

    Brainfuck/Ook!
    形如:
    ++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++++…+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.(Brainfuck)

    Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.

    Ook. Ook. Ook. Ook. Ook! Ook? Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook.
    Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook? Ook! Ook? Ook.

    JSFuck
    形如:
    [][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+

    凯撒密码(数字相关)
    这类密码是运用了字母之间的偏移量,为古典加密方式之一。
    明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。
    如:
    明文字母表:ABCDEFGHIJKLMNOPQRSTUVWXYZ
    密文字母表:DEFGHIJKLMNOPQRSTUVWXYZABC

    Unicode编码
    这类密码通常有很明显的前缀&#。
    如下:
    flagrrrrrrrrrrrr
    比如这样

    URL编码
    这个在web里面用到很多
    url编码又叫百分号编码,是统一资源定位(URL)编码方式。
    剩下的其它所有字符必须通过%xx编码处理。 现在已经成为一种规范了,基本所有程序语言都有这种编码,如js等

    MD5
    MD5的典型应用是对一段信息(Message)产生信息摘要(Message-Digest),以防止被篡改。比如,在Unix下有很多软件在下载的时候都有一个文件名相同,文件扩展名为.md5的文件,在这个文件中通常只有一行文本,大致结构如:
    md5摘要算法是16进制,所以最多是到F!!!
    38b8c2c1093dd0fec383a9d9ac940515

    10
    base91编码
    先认识一下base91编码:
    base91是一种将二进制数据编码为ASCII字符的高级方法。它类似于uuencode或base64,但效率更高。base91产生的开销取决于输入数据。它的数量最多为23%(而base64为33%),其范围可以降低到14%,这通常发生在0字节块上。这使得base91在通过电子邮件或终端线路等二进制不安全连接传输较大文件时非常有用。

    顾名思义,base91需要91个字符来表示用ASCII编码的二进制数据。在94个可打印的ASCII字符(0x21-0x7e)中,以下三个字符被省略以构建base91字母表:

    -(破折号,0x2d)

    \(反斜杠,0x5C)

    '(撇号,0x27)
    摘自大佬博客:https://blog.csdn.net/qq_42777804/article/details/99671341
    然后,国内还没有base91解密的免费网站,只能用外网的:
    https://www.dcode.fr/base-91-encoding
    这题是做bugku里base家族得知的,base家族还有另外的成员,先不列举了,之后有机会碰到再继续说。

    11
    核心价值观编码
    就是个由核心价值观组成的编码,什么富强富强民主民主之类的啦
    先前也是闻所未闻,毕竟没想到还有这么奇葩的编码
    链接:https://sym233.github.io/core-values-encoder/

    12
    键盘码
    这个顾名思义,就是由键盘可以看出来的编码
    一般是类似这样:r5yG lp9I BjM tFhBT6uh y7iJ QsZ bhM
    就是各个键所围成的中间的字符

    13
    伪加密
    这类题通常是一个.zip文件然后设置了密码,告诉你这个密码如何如何,让你破解。
    通常一般来说可以使用直接的破解工具爆破,也可以用winhex修改其密码
    比如:
    在这里插入图片描述
    这里的09那个位置改成00就等于把密码置0
    这样就可以直接进入文件

    14
    电报码
    大概可以理解为莫斯的变种吧,可以支持中英文解码
    网址:https://www.qqxiuzi.cn/bianma/dianbao.php
    可以应用于数字直接转中文

    15
    猪圈密码
    猪圈密码(亦称朱高密码、共济会暗号、共济会密码或共济会员密码),是一种以格子为基础的简单替代式密码。即使使用符号,也不会影响密码分析,亦可用在其它替代式的方法。
    简单来说,就是格子图形和英文字母对应

    16
    rot13编码
    凯撒变种
    套用ROT13到一段文字上仅仅只需要检查字元字母顺序并取代它在13位之后的对应字母,有需要超过时则重新绕回26英文字母开头即可。A换成N、B换成O、依此类推到M换成Z,然后序列反转:N换成A、O换成B、最后Z换成M。只有这些出现在英文字母里头的字元受影响;数字、符号、空白字元以及所有其他字元都不变。因为只有在英文字母表里头只有26个,并且26=2×13,ROT13函数是它自己的逆反
    简单来说就是位移量为13的凯撒密码

    未完待续……

    展开全文
    weixin_43982276 2019-10-17 20:57:14
  • 3KB liu914589417 2021-04-30 14:02:23
  • 最近想要学习ctf密码学的部分,于是开始了从百度百科的入门之旅。 这里借助米斯特安全团队的一款工具来进行实际编码解码。 一,凯撒密码明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被...

           最近想要学习ctf密码学的部分,于是开始了从百度百科的入门之旅。

           这里借助米斯特安全团队的一款工具来进行实际编码解码。

          一,凯撒密码

    明文中的所有字母都在字母表上向后(或向前)按照一个固定数目进行偏移后被替换成密文。----百度百科

    其实就是按照特定的顺序将字母替换。比如后移2位,那么a就变成c,d就变成f。

    下面更直观的看一下:

     

    二,Rot13加密

    这种加密与凯撒十分类似,就是凯撒密码中移动13位的结果


    三,培根密码

    这是利用a和b(A和B也行)来表示二进制中的0和1,并以此来表示26个字母,培根密码5位一组。


    这个加密方式主要特征是只有两种不同的字母,都可转换为ab形式

    def就可以表示为AAABBAABAAAABAB


    四,栅栏密码

    百科上的例子:

    一般比较常见的是2栏的栅栏密码。
    比如 明文 :THERE IS A CIPHER
    去掉空格后变为:THEREISACIPHER
    两个一组,得到:TH ER EI SA CI PH ER
    先取出第一个字母:TEESCPE
    再取出第二个字母:HRIAIHR
    连在一起就是:TEESCPEHRIAIHR
    还原为所需密码。
    而解密的时候,我们先把密文从中间分开,变为两行:
    T E E S C P E
    H R I A I H R
    再按上下上下的顺序组合起来:
    THEREISACIPHER
    分出空格,就可以得到原文了:
    THERE IS A CIPHER

    但也存在不是两栏的情况,就需要对密文的总字数分解因数,尝试分栏的种类。

    比如密文 TAHCEIRPEHIESR  14个字母,可以考虑2栏或7栏,解密如下:


    根据不同情况,找到有意义的一组。

    五,Base64编码

    还是先看百科上的例子

    转码过程例子:
    3*8=4*6
    内存1个字节占8位
    转前: s 1 3
    先转成ascii:对应 115 49 51
    2进制: 01110011 00110001 00110011
    6个一组(4组) 011100110011000100110011
    然后才有后面的 011100 110011 000100 110011
    然后计算机是8位8位的存数 6不够,自动就补两个高位0了
    所有有了 高位补0
    科学计算器输入 00011100 00110011 00000100 00110011
    得到 28 51 4 51
    查对下照表 c z E z

    核心思想在于将8位的二进制转换为6位的二进制。

    而6位二进制共64种组合,可以表示10个数字,26个字母的大小写,外加符号+和/。一共64个。

    对应编码


    有一点要特别指出,当明文个数不是三的倍数时,就会出现 明文数*8%6不为零的情况,

    这是如果余数为2,就在末尾补两个等号,如果余数为4,就补一个等号。对于余下的2个或4个二进制

    采用高位补零的方法。

    比如密文:cmFubA== 的明文为ranl

    因此我们可以得出base64编码后的特征:只含有数字,字母,和符号+ / =。

    六,url编码

    这是浏览器方便传输信息和加强安全性的编码。url编码是字符ASCII码的十六进制加上%的格式。

    部分对应表:


    但在url中不是对所有的字符都要进行url编码,一般的字母和数字是不会被编码的。会以原本形式传递。

    七,Unicode编码

    这是对ASCII码表的扩展,可以表示更多的字符,采用2个字节16位的储存形式。解码后可以看到16进制的表示形式。


    其特征为以\u开头

    八,utf8编码

    这是为了利用内存采用的一种编码格式,这里只是看看其特征 &#开头ascii表之外的字符,

    对于能用ascii表示的字符仍用ascii表示还是一个长度,就节省了内存。


    九,hash算法

    hash函数是一系列单向函数,就是这种运算是不可逆的,只可以通过hash运算得到一个hash值,而不能通过hash值得到原始数据。并且经过hash运算后得到的hash值为固定长度。

    十,加盐hash

    网站后台一般只储存用户密码的hash值,但也存在一定风险,因为如果黑客拿到了密码的hash后,可以的通过对比已经存在的明文与哈希的对应数据,进行对比,获得明文密码。因此,有了加盐hash,就是随机的在用户密码后加上一段字符后再进行hash运算,由于黑客不知道加的盐是什么,依然无法得到密码。

    十一,MD5算法

    MD5是hash算法中一种特殊的算法而已,也是hash算法,最后的结果为128个字符,但一般取其中的64或者32位。

        最后附上一个在线MD5解密网站,当然MD5是不可逆的,这个网站只是通过查询已经存在的明文密文对照,进行查询操作

        http://www.xmd5.org/md5/



    展开全文
    zpy1998zpy 2018-05-26 00:56:09
  • 24.09MB weixin_44145452 2020-10-07 15:53:21
  • weixin_39762423 2018-11-05 17:55:36
  • YUK_103 2019-10-15 09:39:55
  • weixin_39756445 2020-12-05 01:22:47
  • hzy_wsq 2020-06-22 20:39:13
  • 1.88MB Chroma_ 2021-07-17 13:45:35
  • weixin_44145452 2020-11-09 20:36:37
  • huster0828 2020-11-11 11:55:17
  • 1.55MB weixin_43253823 2018-09-24 11:52:38
  • qq_43710889 2021-11-22 21:04:17
  • qq_40836553 2018-03-10 19:35:06
  • cyxl0509 2020-10-21 12:30:27
  • weixin_51555115 2021-01-26 22:31:41
  • weixin_52805837 2021-10-14 14:11:57
  • zmx2473162621 2020-01-18 14:43:09
  • zpy1998zpy 2018-05-27 22:52:24
  • hippotomons 2019-10-21 21:51:12
  • weixin_30596343 2017-12-09 13:21:00
  • weixin_43982276 2019-10-20 14:25:44
  • weixin_41038905 2020-04-27 23:28:04
  • weixin_30904593 2017-11-25 23:54:00
  • weixin_42172261 2019-09-04 18:45:44
  • weixin_40871137 2018-08-08 16:00:39

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,817
精华内容 1,926
关键字:

ctf密码学