Python temelli yazdığım şifrelenmiş uygulamanın şifresini nasıl çözerim?

[salazar47]

Arkadaşlar forumda yeniyim python ile çok uğraşıyorum ancak bi sorunum var yaptığım uygulamayı çalıştırmak için bi şifre koymuştum bu şifreyi unuttum bu şifreyi nasıl çözüp veya kaldırayabilirim ?

[acemiyim]

Şifre nasıl oluşturulmuş ve nerede saklanmış durumda?
Mesela md5 ile şifrelenip bir dosyada mı tutuluyor yoksa python betiğinin içinde bir değişkende mi tanımlanmış durumda?

Yoksa şifreleme metodun çok daha özel bişey mi? Mesela bilgisayarın adına ya da kullanıcısına göre verileri alıp o günün tarihine göre bir algoritmadan geçirip anlıp şifreler mi oluşturuyor?

Yani kısaca biraz daha detay vermen gerekiyor bence. Kaynak kodunu da mı şifreledin. Yoksa direk açıp görebiliyor musun? Programı kullanırken özel bir modül kullandın mı şifrelemek için?

Ben de uzman değilim yeniyim. Sen ne kadar detay verirsen yardımcı olacak insanlar o kadar çoğalıyor ve hızlı sonuca gidebiliyor.

[salazar47]

 b-a-s-e-9-4 ile encode edilmiş md5 ile tekrardan şifre oluşturup benim eklediğimle değiştirilebilir ama bunu nasıl yapacağımı bilmiyorum.

[cagriemer]

Kodu gorebiliyorsaniz paylasin ki ne sekilde calistigi anlasilsin. Boylelikle daha kolay yorumlanir sorununuz.

[salazar47]

kusura bakmayın fazla bilgim yok ama şu şekil de

Kod Seç Genişlet

#qpy:console


import BaseHTTPServer, SocketServer, urllib, urllib2, urlparse, zlib, socket, os, common, sys, errno, base64, re
import urllib, md5, os

try:
    import ssl
    ssl_enabled = True
except:
    ssl_enabled = False

# global varibles
listen_port = common.DEF_LISTEN_PORT
local_proxy = common.DEF_LOCAL_PROXY
fetch_server = common.DEF_FETCH_SERVER
google_proxy = {}
if(os.path.isfile("/sdcard/xyz.txt")==False):
    sifre=raw_input("sifreyi girin: ")
    open("/sdcard/xyz.txt", "w").write(sifre)
xy="/sdcard/xyz.txt"
zw="aWYgX19uYW1lX18gPT0gIl9fbWFpbl9fIiBhbmQgbWQ1Lm1kNShvcGVuKHh5KS5yZWFkKCkpLmhleGRpZ2VzdCgpPT0iNGJiYWU5MDM3MDczMTQwODNjNmZlMWJiOGIwZjhmMWUiOgogICAgcGFyc2VDb25mKGNvbW1vbi5ERUZfQ09ORl9GSUxFKQoKICAgIGlmIGxvY2FsX3Byb3h5ID09ICIiOgogICAgICAgIHNoYWxsV2VOZWVkR29vZ2xlUHJveHkoKQoKICAgIGlmIGZldGNoX3NlcnZlciA9PSAiIjoKICAgICAgICBmZXRjaF9zZXJ2ZXIgPSBnZXRBdmFpbGFibGVGZXRjaFNlcnZlcigpCiAgICBpZiBmZXRjaF9zZXJ2ZXIgPT0gIiI6CiAgICAgICAgcmFpc2UgY29tbW9uLkdBcHBQcm94eUVycm9yKCJJbnZhbGlkIHJlc3BvbnNlIGZyb20gbG9hZCBiYWxhbmNlIHNlcnZlci4iKQogICAgcHJpbnQgImh0dHA6Ly9vcGVyYWtvZGxhcmkzLnRrL2ZvcnVtIgogICAgcHJpbnQgIi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIgogICAgcHJpbnQgIkRpbmxlbml5b3IgIDogMTI3LjAuMC4xOiVkIiAlIGxpc3Rlbl9wb3J0CiAgICBwcmludCAiQXBuIFByb3h5ICA6ICVzIiAlIGFwbl9wcm94eQogICAgcHJpbnQgIkZldGNoIFNlcnZlciA6ICVzIiAlIGZldGNoX3NlcnZlcgogICAgcHJpbnQgIkJlZGF2YSBTaXRlIDogJXMiICUgYmVkYXZhX3NpdGUKICAgIHByaW50ICItLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSIKICAgIGh0dHBkID0gVGhyZWFkaW5nSFRUUFNlcnZlcigoIjEyNy4wLjAuMSIsIGxpc3Rlbl9wb3J0KSwgTG9jYWxQcm94eUhhbmRsZXIpCiAgICBodHRwZC5zZXJ2ZV9mb3JldmVyKCk="

class LocalProxyHandler(BaseHTTPServer.BaseHTTPRequestHandler):
    PostDataLimit = 0x100000

    def do_CONNECT(self):
        if not ssl_enabled:
            self.send_error(501, "Local proxy error, HTTPS needs Python2.6 or later.")
            self.connection.close()
            return

        # for ssl proxy
        (https_host, _, https_port) = self.path.partition(":")
        if https_port != "" and https_port != "443":
            self.send_error(501, "Local proxy error, Only port 443 is allowed for https.")
            self.connection.close()
            return

        # continue
        self.wfile.write("HTTP/1.1 200 OK\r\n")
        self.wfile.write("\r\n")
        ssl_sock = ssl.SSLSocket(self.connection, server_side=True, certfile=common.DEF_CERT_FILE, keyfile=common.DEF_KEY_FILE)

        # rewrite request line, url to abs
        first_line = ""
        while True:
            chr = ssl_sock.read(1)
            # EOF?
            if chr == "":
                # bad request
                ssl_sock.close()
                self.connection.close()
                return
            # newline(\r\n)?
            if chr == "\r":
                chr = ssl_sock.read(1)
                if chr == "\n":
                    # got
                    break
                else:
                    # bad request
                    ssl_sock.close()
                    self.connection.close()
                    return
            # newline(\n)?
            if chr == "\n":
                # got
                break
            first_line += chr
        # got path, rewrite
        (method, path, ver) = first_line.split()
        if path.startswith("/"):
            path = "https://%s" % https_host + path

        # connect to local proxy server
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect(("127.0.0.1", listen_port))
        sock.send("%s %s %s\r\n" % (method, path, ver))

        # forward https request
        ssl_sock.settimeout(1)
        while True:
            try:
                data = ssl_sock.read(8192)
            except ssl.SSLError, e:
                if str(e).lower().find("timed out") == -1:
                    # error
                    sock.close()
                    ssl_sock.close()
                    self.connection.close()
                    return
                # timeout
                break
            if data != "":
                sock.send(data)
            else:
                # EOF
                break
        ssl_sock.setblocking(True)

        # simply forward response
        while True:
            data = sock.recv(8192)
            if data != "":
                ssl_sock.write(data)
            else:
                # EOF
                break

        # clean
        sock.close()
        ssl_sock.shutdown(socket.SHUT_WR)
        ssl_sock.close()
        self.connection.close()
   
    def do_METHOD(self):
        # check http method and post data
        method = self.command
        if method == "GET" or method == "HEAD":
            # no post data
            post_data_len = 0
        elif method == "POST":
            # get length of post data
            post_data_len = 0
            for header in self.headers:
                if header.lower() == "content-length":
                    post_data_len = int(self.headers[header])
                    break
            # exceed limit?
            if post_data_len > self.PostDataLimit:
                self.send_error(413, "Local proxy error, Sorry, Google's limit, file size up to 1MB.")
                self.connection.close()
                return
        else:
            # unsupported method
            self.send_error(501, "Local proxy error, Method not allowed.")
            self.connection.close()
            return

        # get post data
        post_data = ""
        if post_data_len > 0:
            post_data = self.rfile.read(post_data_len)
            if len(post_data) != post_data_len:
                # bad request
                self.send_error(400, "Local proxy error, Post data length error.")
                self.connection.close()
                return

        # do path check
        (scm, netloc, path, params, query, _) = urlparse.urlparse(self.path)
        if (scm.lower() != "http" and scm.lower() != "https") or not netloc:
            self.send_error(501, "Local proxy error, Unsupported scheme(ftp for example).")
            self.connection.close()
            return
        # create new path
        path = urlparse.urlunparse((scm, netloc, path, params, query, ""))

        # remove disallowed header
        dhs = []
        for header in self.headers:
            hl = header.lower()
            if hl == "if-range":
                dhs.append(header)
            elif hl == "range":
                dhs.append(header)
        for dh in dhs:
            del self.headers[dh]
        #del self.headers["Host"]
        # create request for GAppProxy
        params = urllib.urlencode({"method": method,
                                   "encoded_path": base64.b64encode(path),
                                   "headers": base64.b64encode(str(self.headers)),
                                   "postdata": base64.b64encode(post_data),
                                   "version": common.VERSION})
        # accept-encoding: identity, *;q=0
        # connection: close
       
       
     

        request = urllib2.Request( "http://"+bedava_site+"="+fetch_server)
        request.add_header("Accept-Encoding", "identity, *;q=0")
        request.add_header("Connection", "close")
        #request.add_header("Host",bedava_site)
        # create new opener
        if local_proxy != "":
            proxy_handler = urllib2.ProxyHandler({"http": local_proxy})
        else:
            proxy_handler = urllib2.ProxyHandler({"http":apn_proxy})
        opener = urllib2.build_opener(proxy_handler)
        # set the opener as the default opener
        urllib2.install_opener(opener)
        try:
            resp = urllib2.urlopen(request, params)
        except urllib2.HTTPError, e:
            if e.code == 404:
                self.send_error(404, "Local proxy error, Fetchserver not found at the URL you specified, please check it.")
            elif e.code == 502:
                self.send_error(502, "Local proxy error, Transmission error, or the fetchserver is too busy.")
            else:
                self.send_error(e.code)
            self.connection.close()
            return
        except urllib2.URLError, e:
            if local_proxy == "":
                shallWeNeedGoogleProxy()
            self.connection.close()
            return

        # parse resp
        # for status line
       
        line = resp.readline()
        print line
        words = line.split()
        status = int(words[1])
        reason = " ".join(words[2:])
        print status,reason

        # for large response
        if status == 592 and method == "GET":
            self.processLargeResponse(path)
            self.connection.close()
            return

        # normal response
        try:
            self.send_response(status, reason)
        except socket.error, (err, _):
            # Connection/Webpage closed before proxy return
            if err == errno.EPIPE or err == 10053: # *nix, Windows
                return
            else:
                raise

        # for headers
        text_content = True
        while True:
            line = resp.readline().strip()
            # end header?
            if line == "":
                break
            # header
            (name, _, value) = line.partition(":")
            name = name.strip()
            value = value.strip()
            # ignore Accept-Ranges
            if name.lower() == "accept-ranges":
                continue
            self.send_header(name, value)
            # check Content-Type
            if name.lower() == "content-type":
                if value.lower().find("text") == -1:
                    # not text
                    text_content = False
        self.send_header("Accept-Ranges", "none")
        self.end_headers()

        # for page
        if text_content:
            data = resp.read()
            if len(data) > 0:
                self.wfile.write(zlib.decompress(data))
        else:
            self.wfile.write(resp.read())
        self.connection.close()

    do_GET = do_METHOD
    do_HEAD = do_METHOD
    do_POST = do_METHOD

    def processLargeResponse(self, path):
        cur_pos = 0
        part_length = 0x100000 # 1m initial, at least 64k
        first_part = True
        content_length = 0
        text_content = True
        allowed_failed = 10

        while allowed_failed > 0:
            next_pos = 0
            self.headers["Range"] = "bytes=%d-%d" % (cur_pos, cur_pos + part_length - 1)
            #del self.headers["Host"]
            # create request for GAppProxy
           
            params = urllib.urlencode({"method": "GET",
                                       "encoded_path": base64.b64encode(path),
                                       "headers": base64.b64encode(str(self.headers)),
                                       "postdata": base64.b64encode(""),
                                       "version": common.VERSION})
            # accept-encoding: identity, *;q=0
            # connection: close
            request = urllib2.Request("http://"+bedava_site+"="+fetch_server)
            request.add_header("Accept-Encoding", "identity, *;q=0")
            request.add_header("Connection", "close")
            #request.add_header("Host",bedava_site)
            # create new opener
            if local_proxy != "":
                proxy_handler = urllib2.ProxyHandler({"http": local_proxy})
            else:
                proxy_handler = urllib2.ProxyHandler({"http":apn_proxy})
            opener = urllib2.build_opener(proxy_handler)
            # set the opener as the default opener
            urllib2.install_opener(opener)
            resp = urllib2.urlopen(request, params)

            # parse resp
            # for status line
            line = resp.readline()
            words = line.split()
            status = int(words[1])
            # not range response?
            if status != 206:
                # reduce part_length and try again
                if part_length > 65536:
                    part_length /= 2
                allowed_failed -= 1
                continue

            # for headers
            if first_part:
                self.send_response(200, "OK")
                while True:
                    line = resp.readline().strip()
                    # end header?
                    if line == "":
                        break
                    # header
                    (name, _, value) = line.partition(":")
                    name = name.strip()
                    value = value.strip()
                    # get total length from Content-Range
                    nl = name.lower()
                    if nl == "content-range":
                        m = re.match(r"bytes[ \t]+([0-9]+)-([0-9]+)/([0-9]+)", value)
                        if not m or int(m.group(1)) != cur_pos:
                            # Content-Range error, fatal error
                            return
                        next_pos = int(m.group(2)) + 1
                        content_length = int(m.group(3))
                        continue
                    # ignore Content-Length
                    elif nl == "content-length":
                        continue
                    # ignore Accept-Ranges
                    elif nl == "accept-ranges":
                        continue
                    self.send_header(name, value)
                    # check Content-Type
                    if nl == "content-type":
                        if value.lower().find("text") == -1:
                            # not text
                            text_content = False
                if content_length == 0:
                    # no Content-Length, fatal error
                    return
                self.send_header("Content-Length", content_length)
                self.send_header("Accept-Ranges", "none")
                self.end_headers()
                first_part = False
            else:
                while True:
                    line = resp.readline().strip()
                    # end header?
                    if line == "":
                        break
                    # header
                    (name, _, value) = line.partition(":")
                    name = name.strip()
                    value = value.strip()
                    # get total length from Content-Range
                    if name.lower() == "content-range":
                        m = re.match(r"bytes[ \t]+([0-9]+)-([0-9]+)/([0-9]+)", value)
                        if not m or int(m.group(1)) != cur_pos:
                            # Content-Range error, fatal error
                            return
                        next_pos = int(m.group(2)) + 1
                        continue

            # for body
            if text_content:
                data = resp.read()
                if len(data) > 0:
                    self.wfile.write(zlib.decompress(data))
            else:
                self.wfile.write(resp.read())

            # next part?
            if next_pos == content_length:
                return
            cur_pos = next_pos

class ThreadingHTTPServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
    pass

def shallWeNeedGoogleProxy():
    global google_proxy

    # send http request directly
    request = urllib2.Request(common.LOAD_BALANCE)
    try:
        # avoid wait too long at startup, timeout argument need py2.6 or later.
        if sys.hexversion >= 0x20600f0:
            resp = urllib2.urlopen(request, timeout=3)
        else:
            resp = urllib2.urlopen(request)
        resp.read()
    except:
        google_proxy = {"http": common.GOOGLE_PROXY}

def getAvailableFetchServer():
    request = urllib2.Request(common.LOAD_BALANCE)
    if local_proxy != "":
        proxy_handler = urllib2.ProxyHandler({"http": local_proxy})
    else:
        proxy_handler = urllib2.ProxyHandler(google_proxy)
    opener = urllib2.build_opener(proxy_handler)
    urllib2.install_opener(opener)
    try:
        resp = urllib2.urlopen(request)
        return resp.read().strip()
    except:
        return ""

def parseConf(confFile):
    global listen_port, apn_proxy, fetch_server, bedava_site

    # read config file
    try:
        fp = open(confFile, "r")
    except IOError:
        # use default parameters
        return
    # parse user defined parameters
    while True:
        line = fp.readline()
        if line == "":
            # end
            break
        # parse line
        line = line.strip()
        if line == "":
            # empty line
            continue
        if line.startswith("#"):
            # comments
            continue
        (name, sep, value) = line.partition("=")
        if sep == "=":
            name = name.strip().lower()
            value = value.strip()
            if name == "listen_port":
                listen_port = int(value)
            elif name == "apn_proxy":
                apn_proxy = value
            elif name=="bedava_site":
                bedava_site=value
            elif name == "fetch_server":
                fetch_server = value
    fp.close()
exec(base64.decodestring(zw))



[cagriemer]

Python'da yenisiniz, boyle bir uygulama yaziyorsunuz ama yazdiginiz uygulamadan sifrenizi geri alamiyorsunuz oyle mi? Her neyse;

Kod Seç Genişlet

hhakanzn

size bir sey ifade ediyor mu? Biraz da nasilini anlatayim. zw'de tutulun kod su. Yalnizca base64 ile ifade edilmis.

Kod Seç Genişlet

if __name__ == "__main__" and md5.md5(open(xy).read()).hexdigest()=="4bbae903707314083c6fe1bb8b0f8f1e":
    parseConf(common.DEF_CONF_FILE)

    if local_proxy == "":
        shallWeNeedGoogleProxy()

    if fetch_server == "":
        fetch_server = getAvailableFetchServer()
    if fetch_server == "":
        raise common.GAppProxyError("Invalid response from load balance server.")
    print "http://operakodlari3.tk/forum"
    print "--------------------------------------------"
    print "Dinleniyor  : 127.0.0.1:%d" % listen_port
    print "Apn Proxy  : %s" % apn_proxy
    print "Fetch Server : %s" % fetch_server
    print "Bedava Site : %s" % bedava_site
    print "--------------------------------------------"
    httpd = ThreadingHTTPServer(("127.0.0.1", listen_port), LocalProxyHandler)
    httpd.serve_forever()

Bunda da sifre ile ilgili kisim yazilan dosyadaki metinin MD5 hashini alip kontrol etmek. Herhangi bir rainbow table'la denediginizde o hash'in yukarida verdigim metine ait oldugunu goruyorsunuz. Bunu yazdim niye yazdim onu da anlatayim. Oncelikle programi yazan kisiyi birazdan soyleyeceklerimi bilmemekle itham etmiyorum. Vakit harcamak istemeyip citayi biraz yuksek tutmak istemis olabilir. Yani en iyi nasil yapilir biliyordur ama yapmamistir diye varsayiyorum.

Gelelim onemli kisima, MD5 artik guvenli bir hash fonksiyonu degildir, onu da gectim sifre saklamak icin kullanilacak bir sey hic degildir. Ileride siz de boyle programlar yazarsaniz ve amaciniz guvenlikse ayni hatalara dusmeyin. Anahtar turetme fonksiyonlari nelermis, diger yazilim gelistiriciler sifre kontrolunu nasil yapiyorlarmis, neleri uygulamada sakliyorlarmis okuyun, ogrenin. Ondan sonra kendi uygulamanizi tasarlayin. En guncel pratikleri uygulamis olsaniz bile yaziliminizi gelistirirken, tamamen guvenli oldugunu asla dusunmeyin. Guvenlik tek bir yazilim gelistiricinin altindan kalkabilecegi bir konu degildir eger o yazilimcinin adi djb falan degilse. Cok okuyun, cok test yazin. Baskalarindan yaziliminizi test etmelerini isteyin ki sizin hakim olmadiginiz bir alanda acik mevcutsa onlarin tecrubelerinden faydalanabilin. Iyi bir yazilimci ancak oyle olursunuz.