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

#!/usr/bin/env python3

#常见的栅栏解密

e = input('清输入要解密的字符串\n')
elen = len(e)  # 计算字符串长度
field = []
for i in range(2, elen):  # 做一个循环，从2开始到数字elen（字符串长度）
    if elen % i == 0:  # 计算那些数字能整除字符串长度
        field.append(i)  # 将能整出的数字加入到field里面

for f in field:
    b = elen // f  # 用字符串实际长度除以上面计算出能整出的数字f
    result = {x: '' for x in range(b)}
    for i in range(elen):  # 字符串有多少位，就循环多少次
        a = i % b
        result.update({a: result[a] + e[i]})  # 字符串截断，并更新数据
    d = ''
    for i in range(b):
        d += result[i]
    print('分为'+str(f)+'栏时，解密结果为：'+d+'\n')  # 输出结果，并开始下一个循环

    
#W型加密

string=input("输入要加密的字符串\n")
length = len(string)

#猜想不会是一栏,和n栏（滑稽）因为这个就是原来字符串（狗头）
#那么，就暴力遍历一波其中的那些⑧

for i in range(2,length):
    result={x:""for x in range(i)}  
    for a in range(length) :
        width=i*2-2
        num=a%width
        if(num<i):
            result.update({num:result[num]+string[a]})           
        else:         
            ll=2*i-2-num
            result.update({ll:result[ll]+string[a]})               
    d=''
    
    for k in range(i):
        d=d+result[k]
    print("分为"+str(i)+"栏,结果是："+d)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

import re
sss='''1: < ZWAXJGDLUBVIQHKYPNTCRMOSFE < 2: < KPBELNACZDTRXMJQOYHGVSFUWI < 3: < BDMAIZVRNSJUWFHTEQGYXPLOCK < 4: < RPLNDVHGFCUKTEBSXQYIZMJWAO < 5: < IHFRLABEUOTSGJVDKCPMNZQWXY < 6: < AMKGHIWPNYCJBFZDRUSLOQXVET < 7: < GWTHSPYBXIZULVKMRAFDCEONJQ < 8: < NOZUTWDCVRJLXKISEFAPMYGHBQ < 9: < XPLTDSRFHENYVUBMCQWAOIKZGJ < 10: < UDNAJFBOWTGVRSCZQKELMXYIHP < 11 < MNBVCXZQWERTPOIUYALSKDJFHG < 12 < LVNCMXZPQOWEIURYTASBKJDFHG < 13 < JZQAWSXCDERFVBGTYHNUMKILOP <
'''
m="NFQKSEVOQOFNP"
content=re.findall(r'< (.*?) <',sss,re.S)
iv=[2,3,7,5,13,12,9,1,8,10,4,11,6]
vvv=[]
ans=""
for i in range(13):
   index=content[iv[i]-1].index(m[i])
   vvv.append(index)
for i in range(0,26):
   flag=""
   for j in range(13):
       flag+=content[iv[j]-1][(vvv[j]+i)%26]
   print(flag)

 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

#include<iostream>
#include<cstdio>
#define ll long long
ll  gcd(ll a,ll b,ll&aa,ll&bb){
	ll ab=0,ba=0;aa=1;bb=1;
	while(1){
		if(a==0){aa=ba;return b;}
		ba-=(b/a)*aa;bb-=(b/a)*ab;b%=a;
		if(b==0){bb=ab;return a;}
		aa-=(a/b)*ba;ab-=(a/b)*bb;a%=b;
	}
}
ll mod_inverse(ll a,ll mod){
	ll res,temp;
	ll d=gcd(a,mod,res,temp);
	if(d==1)return res;
	return -1;
}
int main(){
	ll p,q,e,d;
	p = 473398607161;
	q = 4511491;
	e = 17;
	std::cout<<mod_inverse(e,(p-1)*(q-1))<<std::endl;
}

 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

def EX_GCD(a,b,arr): #扩展欧几里得
    if b == 0:
        arr[0] = 1
        arr[1] = 0
        return a
    g = EX_GCD(b, a % b, arr)
    t = arr[0]
    arr[0] = arr[1]
    arr[1] = t - int(a / b) * arr[1]
    return g

	
def ModReverse(a,n): #ax=1(mod n) 求a模n的乘法逆x
    arr = [0,1,]
    gcd = EX_GCD(a,n,arr)
    if gcd == 1:
        return (arr[0] % n + n) % n
    else:
        return -1

'''
while True:
	a,b = eval(input())
	print(ModReverse(a,b))
'''

if __name__=='__main__':
	while True:
		l = input("p,q,e:")
		p,q,e = map(lambda x:int(x),l.split(","))
		fn = (p-1)*(q-1)
		#print(l)
		d = ModReverse(e,fn)
		print("d=%d"%d)

1

python solve.py --verbose --private -N 2135733555619387051 -e 17 -p 473398607161 -q 4511491 

1

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

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

#1
$openssl rsa -pubin -text -modulus -in warmup -in pubkey.pem
#2将得到的modulus用python进行转换
$python
>>> 0xC2636AE5C3D8E43FFB97AB09028F1AAC6C0BF6CD3D70EBCA281BFFE97FBE30DD 
87924348264132406875276140514499937145050893665602592992418171647042491658461
>>>
#3 进入网站 http://www.factordb.com/  将大整数分解为p，q
#p= 275127860351348928173285174381581152299 
#q= 319576316814478949870590164193048041239
#4 利用rsatool 生成私钥文件 private.pem
$python rsatool.py -o private.pem -e 65537 -p XXX -q XXX
#5
$openssl rsautl -decrypt -in flag.enc -inkey private.pem

1
2
3
4
5
6
7

>>> a = '/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'
>>> l = a.split('/')
>>> s = ''
>>> for i in range(30):#从i+1开始因为/的原因，l[0] = ''
...     s += chr(int(l[i+1]))
>>> s
'welcometoattackanddefenceworld'

 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

#!/usr/bin/env python
# encoding: utf-8
# 如果觉得不错，可以推荐给你的朋友！http://tool.lu/pyc
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'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

>>> final = 'UC7KOWVXWVNKNIC2XCXKHKK2W5NLBKNOUOSK3LNNVWW3E==='
>>> import base64
>>> a = base64.b32decode(final)#decode3
>>> a
b'\xa0\xbe\xa7Z\xb7\xb5Z\xa6\xa0Z\xb8\xae\xa3\xa9Z\xb7Z\xb0\xa9\xae\xa3\xa4\xad\xad\xad\xad\xad\xb2'
#注意要将a的字节流转换
>>> b = "\xa0\xbe\xa7Z\xb7\xb5Z\xa6\xa0Z\xb8\xae\xa3\xa9Z\xb7Z\xb0\xa9\xae\xa3\xa4\xad\xad\xad\xad\xad\xb2"
>>> s = ''#decode2
>>> for i in b:
...     s += chr((ord(i)^36)-36)
...
>>>
>>> s
'`v_ZomZ^`ZxfciZoZpifc\\eeeeer'
>>> l = ''#decode1
>>> for i in s:
...     l+= chr((ord(i)-25)^36)
...
>>> l
'cyberpeace{interestinghhhhh}'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#编译python文件为.pyc文件
$python -m compileall main.py

#pyc的反编译
#依赖python的uncompyle
$pip install uncompyle

#查看帮助
$uncompyle6 --help
#将models.pyc反编译成models.py
$uncompyle6 models.pyc > models.py

  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
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

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))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

$python ecc_calKey.py
p=15424654874903
a=16546484
b=4548674875
Gx=6478678675
Gy=5636379357093
k=546768
private key: 0x857d0
public key: (0xcb19fe553fa, 0x50545408eb4)

$python
>>> 0x50545408eb4+0xcb19fe553fa
19477226185390
>>>