DEV Community: karapto

Tech Event for Women in Japan and around the World

karapto — Wed, 15 Mar 2023 10:13:25 +0000

There is an programming event for women in Japan. At first, I assumed this was due to the low number of female engineers in Japan, but I have since discovered that similar events take place all around the world.

🎯 CTF for GIRLS (Japan) [1]
🎯 Women Coders Contest Indeed 2022 (Japan, Singapore, India) [2]
🎯 Women in ML Symposium 2022 (Online) [3]

Various other women-only events are also listed on womenhack [4].

Our lab has many female members, including current and alumni. If you know of any events in your country that align with the philosophy of WeCoded 2023, we would appreciate it if you could share that information with us. Such knowledge will undoubtedly benefit others.

Lastly, it's not just women who face obstacles in the tech industry. LGBT individuals also experience discrimination. Although I am only a student and cannot do much, I hope for progress and acceptance for everyone in the field.

P.S.

In the well-known Pokemon series that everyone is familiar with, it is no longer necessary to choose a gender. I think it's a great consideration by Nintendo, a leading technology company in Japan. I hope that other companies will follow suit in the future.

Reference

[1] CTF for GIRLS, http://girls.seccon.jp/, Last Access:2023/03/15

[2] Women Coders Contest Indeed, https://womencodersindeed.com/india?utm_source=&utm_medium=&utm_campaign=&utm_term=&utm_content=, Last Access:2023/03/15

[3] Women in ML Symposium 2022, https://eventsonair.withgoogle.com/events/women-in-machine-learning-2022, Last Access:2023/03/15

[4] womenhack, https://womenhack.com/events/, Last Access:2023/03/15

What is Intel AVX2?

karapto — Sat, 18 Feb 2023 19:06:00 +0000

Abstract of Intel AVX2

Intel AVX2 (Advanced Vector Extensions 2) is an instruction set extension developed by Intel, which is specialized for integer operations. It allows for fast and efficient computations on the CPU, which can result in significant performance improvements in many applications. AVX2 has been supported by many Intel CPUs since the Haswell microarchitecture.

Main Features of AVX2

AVX2 uses SIMD (Single Instruction Multiple Data) instructions to process multiple data elements simultaneously. The main features of AVX2 are as follows:

256-bit YMM registers

AVX2 introduces 256-bit YMM registers, in addition to the 128-bit XMM registers. This allows for twice as many data elements to be processed simultaneously for double-precision floating-point values, integers, and memory access.

Fused Multiply-Add (FMA) instructions

AVX2 introduces Fused Multiply-Add (FMA) instructions, which perform multiplication and addition of two floating-point values simultaneously. This speeds up double-precision floating-point arithmetic significantly.

Integer instructions

AVX2 is specialized for integer operations. It introduces 256-bit integer instructions, which accelerate vector integer operations such as addition, subtraction, multiplication, bit shifts, and bit manipulation.

Gather/Scatter instructions

AVX2 supports Gather/Scatter instructions, which gather data elements from memory into registers or scatter data elements from registers into memory. This speeds up data parallel processing, such as array processing and matrix operations.

Applications of AVX2

AVX2 can result in significant performance improvements in many applications, including:

Image processing

AVX2 is commonly used in image processing. Image processing algorithms often require high-performance operations on large arrays, and AVX2's SIMD instructions are well-suited for these types of operations.

Audio processing

AVX2 is also used in audio processing, which often involves large amounts of data and requires high-performance operations.

Cryptography

AVX2 can accelerate cryptographic algorithms, which often require high-performance operations on large integers.

Scientific computing

AVX2 can improve the performance of scientific computing applications, which often involve large arrays and require high-performance arithmetic operations.

Sample Code

Let's try a sample code.
Before building sample program, you must check that your PC/laptop is supportted Intel AVX2.

$ grep avx2 /proc/cpuinfo
flags : fpu vme de pse tsc msr pae mce cx8 apic sep mtrr pge mca cmov pat pse36 clflush mmx fxsr sse sse2 ss syscall nx pdpe1gb rdtscp lm constant_tsc arch_perfmon rep_good nopl eagerfpu pni pclmulqdq vmx ssse3 cx16 pcid sse4_1 sse4_2 x2apic popcnt tsc_deadline_timer aes xsave avx avx2 hypervisor lahf_lm arat tsc_adjust xsaveopt

If you see the letters avx2 in your shell, let's move on to cloning and making.
We will use the repository linked below.

https://github.com/Triple-Z/AVX-AVX2-Example-Code

$ git clone https://github.com/Triple-Z/AVX-AVX2-Example-Code.git
$ cd AVX-AVX2-Example-Code
$ make run
make[1]: Entering directory '/home/user/AVX-AVX2-Example-Code/Initialization_Intrinsics/src'
gcc -c -o ../obj/setzero.o setzero.c -I../include -mavx -mavx2 -mfma -msse -msse2 -msse3 -Wall -O
gcc -o ../bin/setzero ../obj/setzero.o -I../include -mavx -mavx2 -mfma -msse -msse2 -msse3 -Wall -O
gcc -c -o ../obj/set1.o set1.c -I../include -mavx -mavx2 -mfma -msse -msse2 -msse3 -Wall -O
.
.
.
../bin/permute
float:          1.000000, 3.000000, 2.000000, 3.000000
double:         6.000000, 5.000000
float:          1.000000, 3.000000, 2.000000, 3.000000, 1.000000, 3.000000, 2.000000, 3.000000
double:         6.000000, 5.000000, 6.000000, 5.000000
-e
../bin/permute4x64
double:         1.000000, 3.000000, 2.000000, 3.000000
long long int:   1, 3, 2, 3
-e
../bin/permute2f128
float:          3.000000, 3.000000, 3.000000, 3.000000, 0.000000, 0.000000, 0.000000, 0.000000
double:         3.000000, 3.000000, 0.000000, 0.000000
int:            3, 3, 3, 3, 0, 0, 0, 0
-e
../bin/permutevar
float:          1.000000, 3.000000, 2.000000, 3.000000
double:         5.000000, 6.000000
float:          1.000000, 3.000000, 2.000000, 3.000000, 1.000000, 3.000000, 2.000000, 3.000000
double:         5.000000, 6.000000, 5.000000, 6.000000
-e
../bin/permutevar8x32
float:          8.000000, 7.000000, 6.000000, 5.000000, 4.000000, 3.000000, 2.000000, 1.000000
int:            8, 7, 6, 5, 4, 3, 2, 1
-e
../bin/shuffle
float:          5.000000, 7.000000, 15.000000, 16.000000, 1.000000, 3.000000, 11.000000, 12.000000
double:         4.000000, 7.000000, 1.000000, 6.000000
int:            5, 7, 7, 8, 1, 3, 3, 4
char:           0, 9, 0, 9, 0, 10, 0, 10, 0, 11, 0, 11, 0, 12, 0, 12, 0, 5, 0, 5, 0, 6, 0, 6, 0, 7, 0, 7, 0, 8, 8, 8
-e
../bin/shufflehi
short:          16, 15, 14, 13, 9, 11, 11, 12, 8, 7, 6, 5, 1, 3, 3, 4
-e
../bin/shufflelo
short:          13, 15, 15, 16, 12, 11, 10, 9, 5, 7, 7, 8, 4, 3, 2, 1
-e
make[1]: Leaving directory '/home/user/AVX-AVX2-Example-Code/Permuting_and_Shuffling/src'

If the above message is displayed, make has succeeded.

Summary

In conclusion, Intel AVX2 is a powerful set of instructions that can significantly improve the performance of many applications. Its SIMD instructions, specialized integer operations, and support for gather/scatter operations make it a valuable tool for developers seeking to optimize performance on Intel CPUs.

Reference

[1] Intel® Advanced Vector Extensions 512, https://www.intel.com/content/www/us/en/architecture-and-technology/avx-512-overview.html, Last Access:18/02/2023
[2] AVX / AVX2 Intrinsics Example Code, https://github.com/Triple-Z/AVX-AVX2-Example-Code, Last Access:18/02/2023

picoCTF 2022 ~NSA Backdoor writeup~

karapto — Sat, 09 Jul 2022 05:03:28 +0000

Description

I heard someone has been sneakily installing backdoors in open-source implementations of Diffie-Hellman... I wonder who it could be... ;)

gen.py
output.txt

Solution

First, let's open gen.py. Various functions are written in this file, but the variable c is the most noteworthy part.

#!/usr/bin/python

from binascii import hexlify
from gmpy2 import *
import math
import os
import sys

if sys.version_info < (3, 9):
    math.gcd = gcd
    math.lcm = lcm

_DEBUG = False

FLAG  = open('flag.txt').read().strip()
FLAG  = mpz(hexlify(FLAG.encode()), 16)
SEED  = mpz(hexlify(os.urandom(32)).decode(), 16)
STATE = random_state(SEED)

def get_prime(state, bits):
    return next_prime(mpz_urandomb(state, bits) | (1 << (bits - 1)))

def get_smooth_prime(state, bits, smoothness=16):
    p = mpz(2)
    p_factors = [p]
    while p.bit_length() < bits - 2 * smoothness:
        factor = get_prime(state, smoothness)
        p_factors.append(factor)
        p *= factor

    bitcnt = (bits - p.bit_length()) // 2

    while True:
        prime1 = get_prime(state, bitcnt)
        prime2 = get_prime(state, bitcnt)
        tmpp = p * prime1 * prime2
        if tmpp.bit_length() < bits:
            bitcnt += 1
            continue
        if tmpp.bit_length() > bits:
            bitcnt -= 1
            continue
        if is_prime(tmpp + 1):
            p_factors.append(prime1)
            p_factors.append(prime2)
            p = tmpp + 1
            break

    p_factors.sort()

    return (p, p_factors)

e = 0x10001

while True:
    p, p_factors = get_smooth_prime(STATE, 1024, 16)
    if len(p_factors) != len(set(p_factors)):
        continue
    # Smoothness should be different or some might encounter issues.
    q, q_factors = get_smooth_prime(STATE, 1024, 17)
    if len(q_factors) != len(set(q_factors)):
        continue
    factors = p_factors + q_factors
    if e not in factors:
        break

if _DEBUG:
    import sys
    sys.stderr.write(f'p = {p.digits(16)}\n\n')
    sys.stderr.write(f'p_factors = [\n')
    for factor in p_factors:
        sys.stderr.write(f'    {factor.digits(16)},\n')
    sys.stderr.write(f']\n\n')

    sys.stderr.write(f'q = {q.digits(16)}\n\n')
    sys.stderr.write(f'q_factors = [\n')
    for factor in q_factors:
        sys.stderr.write(f'    {factor.digits(16)},\n')
    sys.stderr.write(f']\n\n')

n = p * q

m = math.lcm(p - 1, q - 1)
d = pow(e, -1, m)

c = pow(FLAG, e, n)

print(f'n = {n.digits(16)}')
print(f'c = {c.digits(16)}')

Looking at the code, we can see that it is very similar to the VerySmooth problem, with the numbers p and q all being SmoothInteger.
It seems that the Pollard'sp-1method can be used to prime factorize (Factorize) the composite number n.
However, we can also confirm that singularly this challenge did not use the RSA technique to generate the ciphertext, but rather the Diffie-Hellman algorithm, as shown in the problem description.

It seems that we can get the flag by solving this discrete logarithm problem.

3^{\text{flag}} \mod n

First, let's look at the contents of output.txt. The contents are given n and c.

→ cat output.txt
n = 5837ab2dd26ff8ab827a4885c72229e2e908af1de303c35e1190659fb120acd3b256cd71d91cc25a96ed4261259c8928720217b1fb8fcc1002375f779ff64fc4f181715d882f304678bed6f376cb0497cb599d88dc4bb4563e33709bd8b8c8e41da4b61ab01eb50d188f532690520a6b69b6c4790d2076eebc32e01d59945b5c3d8af79d0b7eb271527f8c6eb6cf70bdd141a5278d6f9f557513ec56b94da27d7cb85117074d318154967e645f42b4b42231ad8e29f0a3ccd2596444f6cc1de903ec3cb27c28792e9437b6bc1cd57a61f15b96f1690027119cb87c07d96760230afff7f8c9287d0573c34830359694918a721d87213d0baba7ee2f519d839581
c = 40c4c7f7a326558762ac0f64a8abb6f6496851c45a2763791132ecc4c8e029cc0a8c9d6ddb62dbdedf1e4f2f8ba8cb8a965aa9eb8c88cd582274b6ba9402fa84e63a6847c925b3fc34c6d5e9b925f03c656b2a6c2691a15196e4a246c5e3cb46b41f5090bf588911fbd8459ca9da19c1a8f3cd61af905790dd049d16544a2c4fd38f99af62d8080d49b5760c86a0cdb94ddadc785415e4e3e5ddf413a0a10e919c3ddda9c571f26498312718b4da3063a294394dc01fbb2f2c514d2b70dd999980cf5743ecf843450d71a613d74a3ab5d201bf864a617c3a25fecb9191e0ebe9bf678abed2384deb5ce91f753e9f20036fe61edfada631a4876a5cca790bc46

Unfortunately, I couldn't figure out anything from this information alone. So I looked at the hints.

Look for Mr. Wong's whitepaper... His work has helped so many cats!

How to Backdoor Diffie-Hellman

This is a paper presented at DEFCON24. I am not an expert in cryptography, so I don't understand everything, but this gives me a hint to solve the problem.

y = g^x \mod n(=pq)

This figure shows that the difficult problem of finding x from the above equation can be decomposed into a simple problem of finding x from mod p and mod q instead of n.
Finally we can derive the answer to the original question using the Chinese Reminder Theorem (CRT).

In summary, we can get the flags by the following steps:

As in the VerySmooth problem, both the small numbers p and q are SmoothInteger, so the first step is to find out the prime numbers p and q by prime factorizing n in a reasonable amount of time. (Pollard's　p-1　method)
Having found out the prime numbers p and q, the discrete logarithm problem (DLP) of the DP-Hellman algorithm is divided into smaller problems for each prime number p and q, and FLAG_p and FLAG_q are obtained in a reasonable time. (Pohlig-Hellman Algorithm)
Find the final FLAG using ChineseRemainderTheorem(CRT).

import math
from sage import *

N = 0x5bf9961e4bcfc88017e1a9a40958af5eae3b3ee3dcf25bce02e5d04858ba1754e13e86b78a098ea0025222336df6b692e14533dad7f478005b421d3287676843f9f49ffd7ebec1e8e43b96cde7cd28bd6fdf5747a4a075b5afa7da7a4e9a2ccb26342799965f3fb6e65e0bb9557c6f3a67568ccbfaaa7e3d6c5cb79dd2f9928111c3183bf58bd91412a0742bbfb3c5cebfb0b82825da0875c5ee3df208ce563f896d67287c8b9aad9943dd76e5eae1fc8abd473ec9f9e4f2b49b7897954ca77b8f00ed51949c7e4f1f09bd54b830058bd7f4da04e5228250ba062ec0e1d19fb48a05333aada60ecdfc8c62c15773ed7e077edba71621f6a6c10302cc9ed26ec9
B = 100000  

primes = []
for i in range(2, B + 1):
    flag = True
    for j in primes:
        if j * j > i:
            break
        if i % j == 0:
            flag = False
            break
    if flag:
        primes.append(i)

a = 2
for p in primes:
    wow = pow(p, math.floor(math.log(B, p)))
    a = pow(a, wow, N)

print(math.gcd(a - 1, N))

p = 112702077491326624035437448311528244416633038267184436467539953783623022543629307291975209668348933325006075339780165463077524233511267597550006727923822554354936896793276829740193900248027487979522143806746878229772394053610558597354876381637035909859704552979985236170415302488615161107293296362528480525723
q = N // p
assert p*q == N

g = 3
ct = 0x2475123653f5a4b842e7ac76829e896450126f7175520929a35b6a4302788ceff1a605ed30f4d01c19226e09fc95d005c61320d3bbd55cfebbc775332067ac6056c1969282091856eaa44ccaf5738ac6409e865bbd1186d69f718abd2b3a1dd3dc933a07ca687f0af9385406fd9ee4fa5f701ad46f0852bf4370264c21f775f1e15283444b3bf45af29b84bb429ed5a17adc9af78aee8c5351434491d5daf9dd3ce3cf0cd44b307eb403f0e9f482dd001b25ed284c4e6c1ba2864e5a2c4b1afe4161426cc67203f30553c88d7132aef1337eca00622b47cb7a28195f0e3a2ab934e6163b2941a4631412e13b1a72fe34e6480fada9af4dae14f2608805d61ee

flag = 38251710328773353864596243890570950490237
flag = bytes.fromhex(format(flag, 'x'))
print(flag)
# b'picoCTF{cf****b8}'

picoCTF 2022 ~transposition-trial writeup~

karapto — Thu, 07 Jul 2022 08:52:46 +0000

Description

Our data got corrupted on the way here. Luckily, nothing got replaced, but every block of 3 got scrambled around! The first word seems to be three letters long, maybe you can use that to recover the rest of the message. Download the corrupted message here.

First, open message.txt.

heTfl g as iicpCTo{7F4NRP051N5_16_35P3X51N3_V9AAB1F8}7%

To be honest, this challenge needs a bit of an inspiration, but if you replace spaces with underscores (_) and look carefully, you can see the encrypting rules.

"heT" : "The"
"fl_" : "_fl"
"g_a" : "ag_"
"s_i" : "is_"
"icp" : "pic"
"CTo" : "oCT"

If you connect them, you can read The_flag_is_picoCT. Let's separate message.txt by three characters (3-gram) and decode it.

def main():
    f = open("message.txt", "r", encoding="UTF-8")
    txt = f.read()

    n=3
    txt3gram = [txt[i:i+n] for i in range(0, len(txt), n)]
    decode_lst = []

    for i in range(len(txt3gram)):
        decode_lst.append(txt3gram[i][2]+txt3gram[i][0]+txt3gram[i][1])

    print(''.join(decode_lst))


if __name__ == '__main__':
    main()

You can get The flag is picoCTF{7R4N5P051N6_15_3XP3N51V3_A9AFB178}, submit it!

picoCTF 2022 ~morse-code writeup~

karapto — Wed, 06 Jul 2022 02:12:17 +0000

Description

Morse code is well known. Can you decrypt this? Download the file here. Wrap your answer with picoCTF{}, put underscores in place of pauses, and use all lowercase.

Solution

Reading the description, the contents of the file must be written with morse code.
Morse code" is a combination of codes of different lengths, such as "・・・--・, ・-・," to represent letters and numbers.
It can be solved quickly using the following site.

https://morsecode.world/international/decoder/audio-decoder-adaptive.html

Now you have a flag. Please replay several times to avoid accidental conversions. Don't forget to lowercase the string and replace spaces with underscores (_).

Enclose wh47_h47h_90d_w20u9h7 with picoCTF{} and submit it.

picoCTF 2022 ~basic-mod1 writeup~

karapto — Tue, 05 Jul 2022 14:51:20 +0000

Description

We found this weird message being passed around on the servers, we think we have a working decryption scheme. Download the message here. Take each number mod 37 and map it to the following character set: 0-25 is the alphabet (uppercase), 26-35 are the decimal digits, and 36 is an underscore. Wrap your decrypted message in the picoCTF flag format (i.e. picoCTF{decrypted_message})

Solution

The description shows the encryption with the following rules.

A: 0
B: 1
C: 2
D: 3
E: 4
F: 5
G: 6
H: 7
I: 8
J: 9
K: 10
L: 11
M: 12
N: 13
O: 14
P: 15
Q: 16
R: 17
S: 18
T: 19
U: 20
V: 21
W: 22
X: 23
Y: 24
Z: 25
0: 26
1: 27
2: 28
3: 29
4: 30
5: 31
6: 32
7: 33
8: 34
9: 35
_: 36

Read message.txt and calculate mod 37.

def decode(number):
    r = number % 37
    return r

def main():
    f = open("message.txt", "r", encoding="UTF-8")
    lst = f.read().split()
    # print(lst[0])

    dec_lst = []

    for i in range(len(lst)):
        dec_lst.append(decode(int(lst[i])))

    print(dec_lst)

if __name__ == '__main__':
    main()

All that remains is to decrypt the file according to the rules above.

[17, 26, 20, 13, 3, 36, 13, 36, 17, 26, 20, 13, 3, 36, 1, 32, 1, 28, 31, 31, 29, 27]
→ [R, 0, U, N, D, _, N, _, R, 0, U, N, D, _, B, 6, B, 2, 5, 5, 3, 1]

The flag is R0UND_N_R0UND_B6B25531. Enclose it in picoCTF{} and submit it.

picoCTF 2021 -The Numbers writeup-

karapto — Sun, 09 May 2021 00:07:54 +0000

Description

The numbers... what do they mean?

Solution

When the image is opened, the following image is displayed.

Since { appears in the seventh character of the image, we can a find out that the flag format is picoctf{***}. This means that 16→P, 9→I, 3→C, 15→O, 3→C, 20→T, and 6→F are used.
And from this rule, we can assume that Letter Number Cypher (A1Z26), which converts numbers directly into alphabets, is used.

All you need to do is decode A1Z26 with Cyberchef or convert it manually to get the flag.
But don't forget to add {} and type the flag in uppercase.

Flag: PICOCTF{THENUMBERSMASON}

picoCTF 2021 -Easy Peasy　writeup-

karapto — Thu, 06 May 2021 23:38:22 +0000

Description

A one-time pad is unbreakable, but can you manage to recover the flag? (Wrap with picoCTF{}) nc mercury.picoctf.net 36981 otp.py

Solution

$ nc mercury.picoctf.net 36981
******************Welcome to our OTP implementation!******************
This is the encrypted flag!
5b1e564b6e415c0e394e0401384b08553a4e5c597b6d4a5c5a684d50013d6e4b

What data would you like to encrypt? picoCTF{abcdefg}
Here ya go!
41085d333b367227195b540f5033302f

What data would you like to encrypt?

It takes an encrypted 32-byte flag, and shows that it can encrypt any character on input. Next, read the attached otp.py.

#!/usr/bin/python3 -u
import os.path

KEY_FILE = "key"
KEY_LEN = 50000
FLAG_FILE = "flag"


def startup(key_location):
    flag = open(FLAG_FILE).read()
    kf = open(KEY_FILE, "rb").read()

    start = key_location
    stop = key_location + len(flag)

    key = kf[start:stop]
    key_location = stop

    result = list(map(lambda p, k: "{:02x}".format(ord(p) ^ k), flag, key))
    print("This is the encrypted flag!\n{}\n".format("".join(result)))

    return key_location

def encrypt(key_location):
    ui = input("What data would you like to encrypt? ").rstrip()
    if len(ui) == 0 or len(ui) > KEY_LEN:
        return -1

    start = key_location
    stop = key_location + len(ui)

    kf = open(KEY_FILE, "rb").read()

    if stop >= KEY_LEN:
        stop = stop % KEY_LEN
        key = kf[start:] + kf[:stop]
    else:
        key = kf[start:stop]
    key_location = stop

    result = list(map(lambda p, k: "{:02x}".format(ord(p) ^ k), ui, key))

    print("Here ya go!\n{}\n".format("".join(result)))

    return key_location


print("******************Welcome to our OTP implementation!******************")
c = startup(0)
while c >= 0:
    c = encrypt(c)

So far, we know that the encrypted flag is 5541103a246e415e036c4c5f0e3d415a513e4a560050644859536b4f57003d4c, the length of the flag is 32 bytes, and the length of the key is 50000 bytes from the source code. From the source code, we know that the length of the key is 50000 bytes. From the "stop >= KEY_LEN" in the source code, we know that if the start position of the key exceeds 50000, it will return to the beginning. And then, send 32 bytes of \x00 at the second "what data would you like to encrypt?", the key will be visible by xor.

$ python3 -c "print('\x00'*(50000-32)+'\n'+'\x00'*32)" | nc mercury.picoctf.net 36981
31613e5c7862345c7839376b355557525c7863305c7862315c7864345c7831
345c7865345c7865365c7864335c7866335a7733375c786566525b5c783165
245c786639325c7866362f5c7863655c7837665c7861315c7863665c786432
5d525c7831317d355c786465555c7865365c7839665c7865637d5c7866345c
78633334605c7864395c7864345c786638555c7838655c786662645c786633
5c7864335c7861635c7862385c7861375c783831795c786363665c7839615c
7864615c786466785c7831375c7838335c786134735c7866667e5c7839646b
52405c786338695c7865625c7839665c7839335c7831372e5c7831375b5c78
61305c7830315c7861653b5c786231685c7861615c786235535c7866355c78
65667a5c7
.
.
.
What data would you like to encrypt? Here ya go!
6227295e455c7838375c7866375c7862355c786430635c7838665c7863365c78

Now all that is left is to xor the flag 5541103a246e415e036c4c5f0e3d415a513e4a560050644859536b4f57003d4c to the key 6227295e455c7838375c7866375c7862355c786430635c 7838665c7863365c78, the decryption is completed.

Conclusion

In some cryptography, you need to be able to read the given source code to solve the problem. This is a good question that requires Python skills and an idea of how to consume the key.

picoCTF 2021 -Mind your Ps and Qs writeup-

karapto — Mon, 26 Apr 2021 10:14:24 +0000

Description

In RSA, a small e value can be problematic, but what about N? Can you decrypt this?

Decrypt my super sick RSA:
c: 861270243527190895777142537838333832920579264010533029282104230006461420086153423
n: 1311097532562595991877980619849724606784164430105441327897358800116889057763413423
e: 65537

Solution

The RSA cryptosystem uses Euler's theorem, a theorem in number theory, and two prime numbers to implement the public key cryptosystem trick, and the difficulty of prime factorization of large numbers is the basis for its security.

Normally, it is better to implement the RSA cryptosystem and solve the problem, but in actual CTF, it is necessary to solve the problem as fast as possible, and in this article, we will use RsaCtfTool(https://github.com/Ganapati/RsaCtfTool
), which can solve the RSA cryptosystem quickly in CTF. In this article, we will use RsaCtfTool, which can solve RSA cryptosystem quickly by CTF. It is very simple to use, just give c, n, and e as optional arguments, and the plaintext will be returned.

$  python3 /RsaCtfTool/RsaCtfTool.py -n 1311097532562595991877980619849724606784164430105441327897358800116889057763413423 -e 65537 --uncipher 861270243527190895777142537838333832920579264010533029282104230006461420086153423

private argument is not set, the private key will not be displayed, even if recovered.

[*] Testing key /var/folders/1c/vt_z3vzj2h9gnm0gqjtgyv8w0000gr/T/tmpsaz1c036.
[*] Performing pastctfprimes attack on /var/folders/1c/vt_z3vzj2h9gnm0gqjtgyv8w0000gr/T/tmpsaz1c036.
100%|█████████████████████████████████████████████████████████████████| 113/113 [00:00<00:00, 303818.17it/s]
[*] Performing system_primes_gcd attack on /var/folders/1c/vt_z3vzj2h9gnm0gqjtgyv8w0000gr/T/tmpsaz1c036.
100%|███████████████████████████████████████████████████████████████| 6998/6998 [00:00<00:00, 490782.52it/s]
[*] Performing factordb attack on /var/folders/1c/vt_z3vzj2h9gnm0gqjtgyv8w0000gr/T/tmpsaz1c036.
[*] Attack success with factordb method !

Results for /var/folders/1c/vt_z3vzj2h9gnm0gqjtgyv8w0000gr/T/tmpsaz1c036:

Unciphered data :
HEX : 0x007069636f4354467b736d6131315f4e5f6e305f67306f645f31333638363637397d
INT (big endian) : 13016382529449106065927291425342535437996222135352905256639573959002849415739773
INT (little endian) : 3711971977671268622040852236510036125495501942684770673221105381148513202625671168
STR : b'\x00picoCTF{sma11_N_n0_g0od_13686679}'

Conclusion

In the world of hackers, people who can't solve problems well without using tools made by others are called script kiddies. I honestly don't care, but I recommend you to implement RSA cryptography from scratch for the sake of learning.

picoCTF 2021 -Mod 26 writeup-

karapto — Sun, 25 Apr 2021 21:03:13 +0000

Description

Cryptography can be easy, do you know what ROT13 is?

cvpbPGS{arkg_gvzr_V'yy_gel_2_ebhaqf_bs_ebg13_hyLicInt}

Solution

ROT13 is a method of encrypting textual information, in which all the letters of the alphabet are shifted by 13.
In ROT13, the 26 letters of the alphabet are shifted by exactly half to make the text unreadable while preserving the meaning of the string. If the string converted by ROT13 is run through ROT13 again, the string will return to its original state.

Let's use the nkf command to solve the problem in one-liner.

$ echo "cvpbPGS{arkg_gvzr_V'yy_gel_2_ebhaqf_bs_ebg13_hyLicInt}" | nkf -r

This gives us the following flags.

picoCTF{next_time_I'll_try_2_rounds_of_rot13_ulYvpVag}

nkf stands for "Network Kanji Filter," and is a command for converting character codes and newline codes, which can be a problem when exchanging text data between different operating systems, such as Linux and Windows [1].

The option "-r" means the decryption process by ROT13, which can be decoded by ROT13 just by adding it to nkf.

Conclusion

In this article, I solved the cipher of ROT13 by nkf. In fact, if you want to determine ROT13 without any hint from the problem text, you can check it with a frequency analysis[2]. Here is the reference.

Reference

[1] "nkf(1) - Linux man page",https://linux.die.net/man/1/nkf

[2] Andress, Jason. The basics of information security: understanding the fundamentals of InfoSec in theory and practice. Syngress, 2014.

Graph Analytics with Python -Node Similarity-

karapto — Tue, 09 Feb 2021 09:52:39 +0000

Node Similarity

There are many link prediction methods to predict what edges will be formed from a given graph. One of the simplest approaches is to calculate the similarity between nodes, assuming that edges are likely to be formed between nodes with high similarity. The following four methods are used to calculate the similarity of nodes.

Common Neighbors
Jaccard Coefficient
Admic/Adar
Preferential Attachment

1. Common Neighbors

In Common Neighbors, given a graph G and two vertices v and w, the set of nodes adjacent to v is denoted by
Γ(v), and the following formula is used to calculate the similarity between v and w.

|\Gamma (v) \cup \Gamma (w)|

In Common Neighbors, given a graph G and two vertices v and w, the set of nodes adjacent to v is denoted by Γ(v), and the following formula is used to calculate the similarity between v and w.

import networkx as nx
import matplotlib.pyplot as plt
G = nx.karate_club_graph()
plt.figure(figsize=(5,5))
nx.draw_spring(G, node_size=400, node_color="#00C98D", with_labels=True, font_weight="bold")
x = 4
y = 5
print("vertex pair:", x, "and", y)
print("neighbors of", x, ":", list(G.neighbors(x)))
print("neighbors of", y, ":", list(G.neighbors(y)))
print("degree of", x, ":", G.degree(x))
print("degree of", y, ":", G.degree(y))
print("common neighbors:", len(list(nx.common_neighbors(G, x, y))))

vertex pair: 4 and 5
neighbors of 4 : [0, 6, 10]
neighbors of 5 : [0, 6, 10, 16]
degree of 4 : 3
degree of 5 : 4
common neighbors: 3

2. Jaccard Coefficient

Common Neighbors was simply the number of common neighboring nodes. However, this does not tell us how much of the total is made up of neighboring nodes.

On the other hand, Jaccard Coefficient is the ratio of common neighbors to all neighbors of v and w.

\frac{|\Gamma (v) \cap \Gamma (w)|}{|\Gamma (v) \cup \Gamma (w)|}

print("Jaccard coefficient:", list(nx.jaccard_coefficient(G, [(x, y)]))[0][2])

Jaccard coefficient: 0.75

3. Adamic/Adar

Adamic/Adar is a modification of Common Neighbors. Adamic/Adar is an improvement on Common Neighbors in that it does not simply count common neighbors as the same, but rather focuses on the nodes with the lowest degree among the common neighbors.

\sum_{x \in \Gamma (v) \cap \Gamma (w)} \frac{1}{\log |\Gamma (x)|}

print("Adamic/Adar:", list(nx.adamic_adar_index(G, [(x, y)]))[0][2])

Adamic/Adar: 1.9922605072935597

Preferential Attachment

In Preferential Attachment, nodes with more neighbors are considered to be more similar to each other.

|\Gamma(v)| ・ |\Gamma(w)|

print("preferential attachment:", list(nx.preferential_attachment(G, [(x,y)]))[0][2])

preferential attachment: 12

Conclusion

In this article, we have explained the method for calculating the similarity of nodes used in link prediction. In the next article, we will discuss link prediction.

RSA-OAEP

karapto — Mon, 25 Jan 2021 09:51:40 +0000

Existing RSA ciphers do not satisfy indistinguishability under adaptively chosen ciphertext attacks.
The RSA-OAEP cryptosystem is an adaptation of the RSA cryptosystem that is secure against adaptively chosen ciphertext attacks.

The security of public key cryptography is determined by two models: the decryption model and the attack model.

The attack model is a specific model that considers the assumptions of whether the attack method is unknown or known, plaintext or ciphertext, and can be roughly divided into Ciphertext-Only Attack, Known-Plaintext Attack, Chosen-Plaintext Attack, Adaptive Chosen-Plaintext Attack, Chosen-Ciphertext Attack, and Adaptive Chosen-Ciphertext Attack.

Ciphertext-Only Attack(COA)
Known-Plaintext Attack(KPA)
Chosen-Plaintext Attack(CPA)
Adaptive Chosen-Plaintext Attack(CPA2)
Chosen-Ciphertext Attack(CCA1)
Adaptive Chosen-Ciphertext Attack(CCA2)

On the other hand, the decoding model is a property that guarantees the difficulty of decoding a ciphertext, and is divided into Onewayness (OW), Semantic Security (SS), Indistinguishability (IND), and Non-Malleability (NM). However, SS and IND are known to be equivalent.

Onewayness
Semantic Security
Indistinguishability
Non-Malleability

The first step is to load the Crypto module. If you don't have it, or if you want to run it in Google Colab or other environment, you need to install it by pip.

!pip install Crypto 
!pip install pycrypto 

import Crypto.PublicKey.RSA as RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.PublicKey import RSA
from Crypto.Hash import SHA512
import binascii

After the module is loaded, the next step is to create an instance to implement the RSA cipher, setting the bit to 9216 and setting the e, d, p, q, n, and u values to be used in the RSA cipher.

rsa_fact = RSA.RSAImplementation()
rsa_key = rsa_fact.generate(bits=9216) 
print(f"e = {rsa_key.e}")
print(f"d = {rsa_key.d}")
print(f"p = {rsa_key.p}")
print(f"q = {rsa_key.q}")
print(f"n = {rsa_key.n}")
print(f"u = {rsa_key.u}")

e = 65537
d = 54712778709843758446774472112947462605632784372693122692337276261706132343656126613850926869326406853031970937071342771082822051125805156814265100039334033193394094696992133614788847524124626876788542754592152526755990085909097407899383965497160111603490967247421144341240388433715972885769118066232454391706407281337508657486450869604612564915186037245926381485539948826749394883310642506522860818664271873435204459633736609361644611422172966074295803766199657927782114843907265391913377990158502268099171524921346814639644811634440213721098581488684823081553716072399909286975689372830754895978161079557740719349489560157014980070304726939194392515589389021598696807451490025331025472197541696176574536959564303309782584754250421256847013629445055202895707583429013726974641572883140706464114649362282002536217020801728046128596891191308549622359954181692893371397911637301634686429007441755812855730453915884304296900810588878381229626826762914932745596513434539904181264409311386739871120866568366112158792401213076791241640316240227716212342340269517372470349100996450241482980418865133120619705113594803125536458461903619411425887272770066832982698961431770946272179026490471026816477218733565162061250660114444677999978434132079969423273815362068487751387394001307409566746300482655950466254595004445848729603426974921743117321067583048597487994378747311788421673087176130320191643106706361050698733121878677309152032982200158816636173380076359282229190818958256050449423833086070508663202237289102343430444821667542376265505316574669575266888317615128990541614257673495565638717070299695356619528982437194031623223088997989273538527254541439966436390623411911288976594498254117975827186468761820788181917166160655908222038793192188787506057536765607981183236859861486667943287248863826085430979006295460903969125791512868790008624781444689451536552698147817497993529092563912042411447572632795718879409128809355718412607317831057712125337650191691644798974837098670800670701720810017663061318642521588450469140323451770630715595160815378232359863222296870117263678477582812648780595241664724700622530881004222017746966822917700708971417727097797617274650711675753090288153743294368349630966560446422220442000918908188890792339274543542052469683247718010214669699817444469516823417411264300171803938680624000616913222168448190238169463586309217889800457740939560491028217682579223583692099585650500567564310601363376397288638834272224138612305281785850918201163739271142648677843587525732067833869534084619217243476545179795365399703843687277297783992127210539155348404705206088773242790273376856944095440344175614153608432945927894754645537955829484068839908334168255572223279897229878546502328722404499946139267249915380158535466834444509333020445069897893353705865
p = 12130072046886278833181693082100614705209490447837726916478795788322960425187433549273910811163858383006895211566493794758543314214469285471236812510994877816735418918530066077217991730693600041466398450508367310195026540236275364218960767726620386759305379726879156874372965815470952269630302500173347327737693854988729268125509953762486822230357042090218143277836388276304773217375314690742789099130276227817495338520710275364341485155649268557827356048679509841643856093386007904154178133172759581155257670650028891335450188812289959428036381574569572848288535147607757369434016439509738989561427640240846187462354047641648721167182151585825057563180217175344933304090734367449738582350990303309378180110441897589353963213209371167770839804116617001521473687963876715344669709618814276909295668483541284565699994873849455930797486697856953941240424898746290877655182663159735474084712028149263972582942278156444963327822302574036936538681387111065077622844779223675297781440327259496102826382911113441313895030709814775627366783374611349731038590334887254584403840920672527132497102789239488068413183210713915507467132039515076945406086964071206518087086227370462515386332255612649671257472939512949302542353425786572795169262367563943848996139195471409494525329479762489213230006644732987840867198923512825208227632540582309134086997973750198226191910215295385938719089111438470634629
q = 12519805089236855940644210164209487623056371482442480033891581785951665924652122387636234172969095523357832081173146423080702422310354655826250129936269506566322422748900965223409189685589013330288514205723610286815010104443004435906187760806971871410953314908142729011749321942800951734468583784583950464476258455128461462235794149719745985882483978225051023582170954741174070891339318418665713855921985629953661579695382235034076281235217675973909551120871901574560206528446274641484268876807337164011673574772349829718276881142444789314205845707277490045469191728542280765995963818552845065797299975252921830778632300367309810556300770135093908113204393740605060086069333971785454040389147500355972790011429678646857816729014936550909634890407619686980073019768893724302757522559371788273933025350731188260796680491797869578748755298530752042259929172172073220561245954937796837582346075129004838903435323759761168335338503154239996870811663325163467144633044444683305828032595987699706984427334806391388798223770770759146765627296261487267519617152876345941957791634282765073377692982823376414652977870529648753561689121940883129724099795198962660636134643368278840349884630792737349208594102964824563232263117048499819487289804609056850410444299774680189540308196827320365488901128335582300667298664516455480259598865327627717566900947312780072998889331304668363400401827709600071239
n = 151866137745416559964688432462252249239140899980229095840401002683640455525229408745582490967559388671685073876703425995868659047250514275640019137744180023438036033380914550875118237270278923875485609525547664230486100642083118750645967004649840423283977278408125006848158542068546174029674757134669279720014519249375981740955043439129113280540703372283523665385533506681575328976643495741391246854127329878841344910042615567647880348090930061310877306824167844716998706557331347761205669109356561058168455560068201524333505654994973033189599666893563900313234758808897245137458208226132276634522923326880507116344394447673130775861571339181482482838261055792152547230949485485160281918233462798793958977964464264368862871417530382360339787905338214511548684422311095363378810078439811633541090245023754843090765104920708608662481659311540740188920601296243579385934731056449842549849555745641891793062841823104046872474203700111069867691048475759431932072284145501744963259734574577644781400543487823891091049832633154617237871390683825498174930327145964170919879252551961351745800165650088065988463598732057618833716412594871261980363991170720004793830919289906082158307435479479890071215428577428318411256808772197740971775301245780566519550041818808287737185025651759082663836868185668672470752081352181931650163897914338498101726771682277579669251094827096382101189662202450247528706801595182126253780755239694355924054815116591597638863241923224957759401328356378516951298552036613701403430346061627363679308261625674587619186822019969489756671012716817953167343781500006912276898198404318225817544624942139706545510714957768405724130224044295151751258549947354541150305045790078113589355945586278683046582782171793878106819223191188021984804727473789164194402818429740290591778754298559738921522474090291994429142317273233206117290986481681738738095664842469126723615623734749386881345694943175511880029898076319845417819110458926783344321175294806398526366996857765614996690254307549487134315691991028833945558109920098447456971122417762047751568805600928997384384901221399979066351526851503503362633626878650964501615886068743543944340472537664872044563469147981087766547141773072969618866988862626405646237369965807693949174786994560543281886370835506173995971701526182793145750359730095459848775071019405310123102485875350194023236625930364934091839491472058169530377591119011866264555545140737823811539715806258841365400919854827823652643926926193766906212264774344672386155195669948088831284534824735348516353444624174191126137172153322802381084234378129779213443880989004389935095956015922766705668107643657680934715125161267797159590647680270188197204888730459846953067030083669037671381538306240840673142093309452688601121676213823304404229039280947940335331
u = 10781822158372164742305626294850686816831936241525441028001043230411582088038973667162094571894187799999749147562041473604748123629150416928301030140990157623156390638612027288675572338366206717697612690947583061508263153619828286332612888722304000580433813985435206665463379094804702738936656626553314167402691854837491124299938995328452085547321260975589522866500856536443154265563359114784492581927028546354540248880733201762730703819908738348842889637325263821921965997752379810807238918240061069181254153221962474923573838098699018734758805819683376921483153685826373880726336969800504033784742731823112064241774768842814076116633600658679876600047133526288364915626666661753097150236067251142522143737634832651262466849731567407483241432201831247209145398769142292010779623659758305502902229581712596101308986885819673232808246175699681672202309156701075927859899886829767012503005194934421294783981572466821103049254421135653208178444947763051815002282479680402390074943146793557595444822691075774625011960189188631315907051066786786183550298038765045896809870184328342874576998223471703093795866581191011541245524753621535560250397713625184569644431536651498541155015903163493369214406453958554598704502289203541177059659769715495474329271405160176325178717639725228119763163665086490064099329801540922235306326637478727213854429773502229254532779759856101596122507840306436792107

Next, each of the values created above is encrypted. The hash function used for the encryption is SHA512.

message = u'This is plain Text'.encode('utf-8')
P = binascii.b2a_hex(message)
key = rsa_key
cipher = PKCS1_OAEP.new(key, hashAlgo=SHA512)
ciphertext = cipher.encrypt(P)
ciphertext

b'G\x82\xed\xe7\x00rH\xb0KF\x8c\xd7-\xafz@\xe0\x8b\x01\x7f\x1f\x8f\x19\x12- \x83\xc6b\xd6V)^\x10\x14\xaf\xa11L=\x93\xba\xa9\x86r\xda2\x99\xa1q\xc8\x97X\xf7P\x8d\x94\x19\xf9\x13*\x13c\x8fD\xa3\x90\x18\xcc\xf9\xcf\xa1jF\x91Z\xe3^r\xb8\x08\xb2;\xb4\x8f\xd0\tf\x18\xee\xda\x0c\x81\xa1S\xf1\xbaZ\x00\xdf\xab\xcf\xb2\xbeW\xc4\xb1\xba\x8a\xbb\xd6\x96\x1f\xac<Q\xa93<\xaf\x99\xc1\x82\x86\xe0\xb3\xbf\xb6,\xf0\xf7\xe0\x98\x19\xa2:\x1fC\xa5W_\r\x99P\xf9\x80\xe3\xeeXy\x14\x88\xfaZN\xd3\xa3!\xcdv\x98\x9fi\xc1\xb3\xd06\xefKx7\x1c\x8d\xd8\xa5z\xb1|\xf8k\xdd\xfc\xce!F\xcb\xfd\xff++\xa7\xf9\xed.\\\x14\xa9\xadc\xd7\xbf@sW\xa5\x94\x9a\x8eB\x05\nk\xc8,\x19\xd9\xb6\x8aY\x92\x86\x17Y\x89\x02\xbfJ\xfe\xd9\xf8A=@\xba\x87\xc2t\xdb\x1f\xd3K\x0f+3\xdfK-4B\xca\xfe}\xd6o\xef\x04GL!\x9f\xee\xe0\xd4{\xee\x07F\xf1\xc9\x82F\xe2Y\xa5\x15\x11.\x88"\x12c;\x84m(\x15h\x89\xba\x1b\xab\x8a\xdc\x844\xfd+\xaa\xbe\r/b\xa5\x08\xa9\xa4\xbb\xb9\xe5\xcdl\xcc_\x9f\x01\x9dP\xed\xe7\x9db\xffF\x14+y\x07\x95\xc8\xd4c\xe7\x98SZC\xfc\xc30\xcf\xa7\x1a6bAUqp\xeehP\xa7Hr\x80UP\xd7\x8dM\x97\xd9\xf0\x18\x02t"\xa0\xeawdL\xc1>"\x1e\xed!\xfc+\x1f\xa3\x98\x1acXd;\xb0\xd4\x904"\x9a\xf6l\xc6\t\x8a\x9d\xb3\x83\xb0p\xc0\x8f6\xe3\xcb\x185\xf3\xba\xf1ux\xe3\x81\x05\xad\xe4>{\xf4w\xdaN\x85\n\x87 \xf6b,Dk\xb0P\xc7\x9e4\xca\xed[9\x14\x89tRF`\xcfC\xc52\xf5\x022\x94! \xef\xd6lU\x8ev\xec(V\xff\xe0M\'vM5\x8e\x8d\x96\xd0Sc~g\xb5\x03a\x1e\xfd_q\xea\xf0\x8b\x9e+sTE\x14\xfd\x8fr\x16a\\\x1cC\xeev\x0e\x13nv\x9e\xd4\x94,\xbc\xa5F6\x9d\xfa`\x04\xf3Xl\x03\x9f\xad\xb8b\x9fI\xf1\xad-\xb1\x06\xbb\x9a\x13C\xa4^\x89O\xf4S\xf5M\xe2m!\x94\xc2\xee<U\xa1xo\x9c\x01r\x8f\xce\\\x11\x18\n\x0cN\x9bhyQ\x03\x04\x005z3\x0b^\xe0\xcc&\xa5\x01\x0c!\x10\x9a\xed5\x87$,! \xe8vq*\x17\xa2\xe4\x05\x93\x015\xa7%\x89\xc6\x0f\x80\xb8\xb1e`I\xc5^\xb7?\xba\xdfh\x1a\xdd+\x14\xd2\x13\xc4\xf1\x98\xfa\xde\xc8#A2\xad\xcf\xcd\x7f\x85\xd1\x8f\x12Z:\x1b\xe6\xcf\xe4-I\xe0M\x93\x0f\x93\xcemq\xedP\xd0zX\x8b7\x84\xc7\n\x96\x95\xbd\xa5D\xaf\xca\x8e_\x9cw\x05\x1d\xb8~4aE\x0c\x96\xe3\xc8"A\xfb"\xc0\xfb\xb2\xf3\xb7\x06\xea\xaa\n\xf17\xe0]uUk\xdd\x85N\xa8\xbc\xeaF\xe8\xc6u\xcb;\x89I_q\xe0^9%\x9ae\x82\x849=\xb4)\x04\xd9\xb9*\xdf\xe1\x93\x84\x83\xef0\xb6\xa5\xf0\xdd<\xce?\xadh\xc6\xb6\x85\xc7\xa1\x9b&\xad\xf5\xb3\xca\x19\x9d\xccT\x11r\xe5\xc0\xc6\x0b\xb8,:~\xe7\xcc\x12u\x8a\xa6\xe0\xce\xf5\xca \xfd\x00\x88\xf5\xf93\xb4\xe8\x89\xd94\xf7\xbf`\xc3\xa5\xc7\x9e\xd3Y\x1a\xda\xcfC\xad\x80l%b\xa0\xd8R2\x88\xfeM\x08\xdc?\xc1\xa2\x01F\xa9\\8\x07i\xc0\x04\xe3\x1f\xd3\xa5\xfa\xde\\[\xd3\x1eg2I\xa4\xcd{Ej\xff\x14\xf7g\xac\xc0\xf7\x82^=\xad\x88\x83\xb8\xa8\x84\xe1\x98\xf8\xc8\xa9\xe2TV\x82\x1cfy\xf5\xcf)oB\x18\x85<\xb7\xe9\x8a\x84\x90\xb8\xd6;\xba\xf0\xc6\xecf\x8b\xdf_,9\xf2\xbf\xd6IuI\xf2\xb8P\x06I\xa5\xaa\xd5WY\xbd\xd1\xf6\xf1B\xba\x11\xd5\xf7\xc7\xd2%\xfc\xa8.\xe0\x15\xef\xbf\xdb\xd1\xebNp \x86\xaa\x15\x1dv\xee!C,\xa1$\xa5\xe9_aI\x01\xb8\xb0\xb9\xa6Z\x97\xf1l\'\xee\x82\x04\xcb\xaf\\p\x0ef\x9b\xb8 \xdcoD\xb8\xc6\xa3\x1c\xe5\x17[\xb4\xc7Q}(\xb8\xb9G\x81\xd6jj\xea(\xb5\xf2\xe6\x84\xd0n\xf9}\x1e\x9f\xe4\xbc\xae\x1d\xd1\xe0\xbf\x97\xfa^\xcb\xb9oc/\x84H$\xe2\xb33\xa6\xd9\xc6I\xe7\xbe\x01[\xff\x95\x12\xcf\xc8rl\xb4\x14\x80>f|\xf0\xb5E\xe4==<b/\xbe\x90\xaa\xbfp\x80\x84\xa2\xa8\xe2o\xf6lR\xfaQ\xa0w\xd2\xbd\xecU<Z\xa2\xc1\xbf\x8b\xff\x1eN\x88[\x9c\xa8\xe8i\x7f\xea\x84\x80\xd6H\x91\xa5\xa6\xbe\xff\x18\x0197\xe239\x16\x0f\x8f'

Finally, we decrypt the ciphertext we created above. When running the program in a notebook, you can measure the execution time by adding the magic command %%time to the top of the cell, and you will see that it takes almost 10 times longer than the encryption case.

M = cipher.decrypt(ciphertext)
message = binascii.a2b_hex(M).decode('utf-8')
message

This is plain Text

DEV Community: karapto

Tech Event for Women in Japan and around the World

P.S.

Reference

What is Intel AVX2?

Abstract of Intel AVX2

Main Features of AVX2

256-bit YMM registers

Fused Multiply-Add (FMA) instructions

Integer instructions

Gather/Scatter instructions

Applications of AVX2

Image processing

Audio processing

Cryptography

Scientific computing

Sample Code

Summary

Reference

picoCTF 2022 ~NSA Backdoor writeup~

Description

Solution

picoCTF 2022 ~transposition-trial writeup~

Description

picoCTF 2022 ~morse-code writeup~

Description

Solution

picoCTF 2022 ~basic-mod1 writeup~

Description

Solution

picoCTF 2021 -The Numbers writeup-

Description

Solution

picoCTF 2021 -Easy Peasy writeup-

Description

Solution

Conclusion

picoCTF 2021 -Mind your Ps and Qs writeup-

Description

Solution

Conclusion

picoCTF 2021 -Mod 26 writeup-

Description

Solution

Conclusion

Reference

Graph Analytics with Python -Node Similarity-

Node Similarity

1. Common Neighbors

2. Jaccard Coefficient

3. Adamic/Adar

Preferential Attachment

Conclusion

RSA-OAEP

picoCTF 2021 -Easy Peasy　writeup-