{
    "info": {
        "author": "Ryan McGuire",
        "author_email": "ryan@enigmacurry.com",
        "bugtrack_url": null,
        "classifiers": [
            "Development Status :: 4 - Beta",
            "License :: OSI Approved :: MIT License",
            "Topic :: Utilities"
        ],
        "description": "curlbomb\n========\n\ncurlbomb is a personal HTTP(s) server for serving one-time-use shell\nscripts.\n\nYou know all those docs for the cool and hip software projects that\nstart out by telling you to install their software in one line, like\nthis?\n\n::\n\n    curl http://example.com/install.sh | bash\n\nI call that a curl bomb... I don't know if anyone else does.\n\n*convenient* as hell, but a security and trustability *nightmare*.\nEspecially since installers usually require root access, do you trust a\nrandom file on the internet with direct access to your machine?\n\nBut I usually try to ask myself this question: is it possible to turn a\n*bad* idea into a *good* one, or at the very least a less-bad idea?\nLet's take a look..\n\ncurlbomb serves a single file (read from disk or stdin) via HTTP to the\nfirst client to request it, then it shuts down. A command is printed out\nthat will construct the curl bomb the client needs to run, which\nincludes a one-time-use passphrase (called a knock) that is required to\ndownload the resource. This command is copy/pasted (or typed) into\nanother shell, on some other computer, which will download and run the\nscript in one line.\n\ncurlbomb has optional (but recommended) integration with OpenSSL to\nsecure communications. OpenSSH is supported as well, to make it easy to\ncurlbomb from anywhere on the internet, to anywhere else, through a\nproxy server that you can forward the port through.\n\nSo does curlbomb measure up to making this a good idea? Decide for\nyourself:\n\n+----------+------------------------+----------+\n| Feature/ | Traditional curl bomb  | Using    |\n| Problem  |                        | curlbomb |\n+==========+========================+==========+\n| Convenie | Yup, sure is.          | I think  |\n| ce       |                        | so.      |\n+----------+------------------------+----------+\n| Trust    | Is it even SSL? Do you | Self     |\n|          | know/trust the URL and | hosted   |\n|          | it's author?           | server   |\n|          |                        | and SSL  |\n|          |                        | verifies |\n|          |                        | connecti |\n|          |                        | on       |\n+----------+------------------------+----------+\n| Security | Even if you verify the | Self     |\n|          | script beforehand,     | hosted   |\n|          | `are you sure it       | script,  |\n|          | hasn't                 | you're   |\n|          | changed? <https://www. | in       |\n|          | idontplaydarts.com/201 | control  |\n|          | 6/04/detecting-curl-pi | of the   |\n|          | pe-bash-server-side/>` | contents |\n|          | __                     | .        |\n+----------+------------------------+----------+\n| Privacy  | Anyone who knows the   | curlbomb |\n|          | URL can download/run.  | requires |\n|          | Cannot contain private | a        |\n|          | information like       | passphra |\n|          | passwords.             | se       |\n|          |                        | (knock)  |\n|          |                        | and only |\n|          |                        | serves a |\n|          |                        | file one |\n|          |                        | time (by |\n|          |                        | default. |\n|          |                        | )        |\n|          |                        | Optional |\n|          |                        | ly       |\n|          |                        | gpg      |\n|          |                        | encrypt  |\n|          |                        | the      |\n|          |                        | contents |\n|          |                        | of the   |\n|          |                        | script.  |\n|          |                        | Put      |\n|          |                        | sensitiv |\n|          |                        | e        |\n|          |                        | data     |\n|          |                        | like SSH |\n|          |                        | keys and |\n|          |                        | passphra |\n|          |                        | ses      |\n|          |                        | into     |\n|          |                        | your     |\n|          |                        | script   |\n|          |                        | as       |\n|          |                        | necessar |\n|          |                        | y.       |\n+----------+------------------------+----------+\n| Repeatab | Is the script going to | It's     |\n| ility    | stay at the same URL   | your     |\n|          | forever? Can you       | script,  |\n|          | specify any parameters | read     |\n|          | or at least a version  | whatever |\n|          | number?                | env vars |\n|          |                        | you      |\n|          |                        | want.    |\n|          |                        | You can  |\n|          |                        | keep it  |\n|          |                        | checked  |\n|          |                        | into     |\n|          |                        | your own |\n|          |                        | git      |\n|          |                        | reposito |\n|          |                        | ry       |\n|          |                        | and      |\n|          |                        | serve it |\n|          |                        | from     |\n|          |                        | anywhere |\n|          |                        | anytime. |\n+----------+------------------------+----------+\n\ncurlbomb is well tested, but not intended for heavy automation work.\nThere are better alternatives to choose from (saltstack, ansible,\npuppet, etc.) curlbomb can be used effectively in doing the front work\nfor setting up these other tools, like copying SSH keys and installing\npackages.\n\nInstall\n-------\n\ncurlbomb can be installed from the `Arch User\nRepository <https://aur.archlinux.org/packages/curlbomb/>`__ (AUR):\n\n::\n\n    pacaur -S curlbomb\n\nOr from the `Python Package\nIndex <https://pypi.python.org/pypi/curlbomb>`__ (PyPI):\n\n::\n\n    pip install curlbomb\n\nDependencies\n~~~~~~~~~~~~\n\n-  Python 3.5 (I haven't tested anything lower)\n-  `Tornado <http://www.tornadoweb.org/>`__\n-  `Requests <https://pypi.python.org/pypi/requests>`__\n-  `psutil <https://pypi.python.org/pypi/psutil/>`__\n-  OpenSSL (optional, if using --ssl)\n-  OpenSSH (optional, if using --ssh)\n-  GnuPG (optional, if using encrypted SSL cert or resources)\n-  `python-notify2 <https://pypi.python.org/pypi/notify2>`__ (optional,\n   for desktop notifications when using ping subcommand)\n-  curl (on the client machine, preferably version >= 7.39.0, for\n   --pinnedpubkey support)\n\nExample Use\n-----------\n\nServe a script stored in a file:\n\n::\n\n    curlbomb run /path/to/script\n\nThis outputs a curl command that you copy and paste into a shell on\nanother computer:\n\n::\n\n    KNOCK=nDnXXp8jkZKtbush bash <(curl -LSs http://192.0.2.100:48690)\n\nOnce pasted, the script is automatically downloaded and executed.\n\nBy default, the client must pass a KNOCK variable that is passed in the\nHTTP headers. This is for two reasons:\n\n-  It adds a factor of authentication. Requests without the knock are\n   denied.\n-  It helps to prevent mistakes, as the knock parameter is randomly\n   generated each time curlbomb is run and can only be used once. (See\n   ``-n 1``)\n\n(Astute readers will notice that the KNOCK variable is being fed to the\nscript that is being downloaded, not into the curl command. That's\nbecause it's really a curlbomb within a curlbomb. The first curl command\ndownloads a script that includes a second curl command that *does*\nrequire the KNOCK parameter. This nesting allows us to keep the client\ncommand as short as possible and hide some extra boilerplate. See\n``--unwrapped``.)\n\nIf you want just the curl, without the bomb, ie. you just want to grab\nthe script without redirecting it to bash, use ``--survey``. This is\nuseful for testing the retrieval of scripts without running them.\n\nYou can pipe scripts directly into curlbomb:\n\n::\n\n    echo \"pacman --noconfirm -S openssh && systemctl start sshd\" | curlbomb\n\nWhenever you pipe data to curlbomb you can omit the ``run`` subcommand,\nit's assumed that you want to run a script from stdin.\n\nThis works in shell scripts too:\n\n::\n\n    cat <<EOF | curlbomb\n    #!/bin/bash\n    echo \"I'm a script output from another script on another computer\"\n    EOF\n\nOr type it interactively:\n\n::\n\n    $ curlbomb run -\n    pkg instll sqlite3\n    echo \"bad idea, I don't have spollcheck when I typ in the terminal\"\n\n(The single dash says to read from stdin, even when nothing is being\npiped. Ctrl-D ends the interactive input.)\n\nThe shebang line (#!) is interpreted and automatically changes the\ninterpreter the client runs, the following example runs the script with\npython instead of the default bash:\n\n::\n\n    cat <<EOF | curlbomb\n    #!/usr/bin/env python3\n    import this\n    print(\"Hello, from Python!\")\n    EOF\n\ncurlbomb can also transfer files and directories with ``put`` and\n``get`` subcommands:\n\n::\n\n    # Recursively copy a directory \n    # (to whatever directory the client is run from):\n    curlbomb put ~/.ssh\n\n    # Recursively copy a remote directory to the server\n    # (to whatever directory the server is run from)\n    curlbomb get /var/log \n\n    # Recursively copy a directory\n    #  - Specifies the explicit remote destination directory.\n    #  - Environment vars in single quotes are evaluated on the remote end.\n    #  - Excludes some files you may want to keep private.\n    curlbomb put ~/.ssh '$HOME' --exclude='*rsa'\n\nThe ``put`` and ``get`` subcommands are just convenience wrappers for\nrunning tar on both ends of the curlbomb pipe. You *could* achieve the\nsame thing more generically:\n\n::\n\n    # Copy a local directory to a client, the hard way:\n    tar cjh -C $HOME .ssh | curlbomb run -c \"tar xjv -f\"\n\n    # Copy a remote directory to the server, the hard way:\n    echo \"tar cjh -C /var log\" | curlbomb -l --client-quiet | tar xjv\n\nThe first example has a ``run -c`` parameter that tells the client that\nwe want to interpret the data as being a tar archive rather than a\nscript. The second example has a ``-l`` parameter that will output the\ndata received to stdout, in this case piped directly into tar.\n\nSSH tunnel\n~~~~~~~~~~\n\nBy default, curlbomb constructs URLs with the IP address of the local\nmachine. This usually means that clients on another network will be\nunable to retrieve anything from curlbomb, unless you have a port opened\nup through your firewall (and appropriate use of the ``--domain`` and\n``--port`` arguments.) As an alternative, curlbomb can be tunneled\nthrough SSH to another host that has the proper port open. For instance:\n\n::\n\n    echo \"apt-get install salt-minion\" | curlbomb --ssh user@example.com:8080\n\nThe above command connects to example.com over SSH (port 22 by default)\nand forwards the curlbomb server port to example.com:8080. The URL that\ncurlbomb prints out will now use the domain name of the ssh server,\ninstead of the local IP address. The SSH tunnel is left open for as long\nas the curlbomb server remains running. Any user directly on the\nexample.com host will be able to fetch the resource from localhost:8080.\nHowever, by default, SSH does not open this up to the rest of the world.\nIf you want any client to be able to connect to example.com:8080 you\nwill need to modify the sshd\\_config of the server to allow\nGatewayPorts:\n\n::\n\n    # Put this in your /etc/ssh/sshd_config and restart your ssh service:\n    GatewayPorts clientspecified\n\nTLS / SSL security\n~~~~~~~~~~~~~~~~~~\n\nFor extra security, you can enable TLS with ``--ssl``:\n\n::\n\n    echo \"PASSWORD=hunter2 run_my_server\" | curlbomb --ssl /path/to/cert.pem\n\nThe example above is passing a bit of secure information; a password.\nEven without TLS, curlbomb secures access with a knock parameter. For\nmany use-cases, this is sufficient to secure it, as curlbombs are short\nlived and can only be retrieved one time (``-n 1``). However, the\nconnection itself might be spied on (or even modified!) through traffic\nanalysis at your ISP or any other router your connection flows through.\nUsing TLS makes sure this doesn't happen.\n\nNote that when the ``--ssl`` parameter is combined with the ``--ssh``\nparameter, the SSL certificate should be generated for the host running\nthe SSH server rather than the one running curlbomb. To prevent having\nto store the SSL certificate in plain text on your local machine, the\nfile may be optionally PGP encrypted and curlbomb will decrypt it only\nwhen necessary.\n\nYou can also specify the SSL certificate path as a single ``-``. In this\ncase, a new self-signed certificate will be generated and used for this\nsession only.\n\n``--pin`` can be used to extract the SSL certificate fingerprint and\ndirectly provide it to the client curl command (requires curl >=7.39).\nThis avoids having to trust the client's CA root certificate store, and\ntrusts your certificate explicitly. When generating a self-signed\ncertificate with ``--ssl``, the ``--pin`` option is turned on\nautomatically. Pinning adds some extra security benefits, but makes the\nclient command you have to paste/type much longer than it usually is,\nfor example:\n\n::\n\n    $ echo \"whoami\" | curlbomb --ssl -\n    WARNING:curlbomb.server:No SSL certificate provided, creating a new self-signed certificate for this session\n    Paste this command on the client:\n\n      KNOCK=bbxfOV1ToDVhJjAl bash <(curl -LSs -k --pinnedpubkey 'sha256//RSkhZc2Qw/j8AxHMLUzipRpegEK9I0BlX7J1I5bcg0Y=' https://192.0.2.100:39817)\n      \n\n``--pin`` is a different kind of trust model then using a certificate\nsigned by a CA. When you use ``--pin`` you are completely bypassing the\nroot CA certificate store of the client machine and instructing it to\ntrust your certificate explicitly. This mitigates many man-in-the-middle\ntype attacks that can happen with TLS, but you still need to take care\nthat the client command is not modified or eavesdropped before being\npasted into the client.\n\nAliases\n~~~~~~~\n\nBy now the curlbomb command might be getting quite long. Once you've\nencrypted and stored your SSL certificate, and setup your SSH server,\ncreate an alias for ease of use, for example:\n\n::\n\n    alias cb=curlbomb --ssl ~/.curlbomb/curlbomb.pem.gpg --ssh user@example.com:22:8080\n\nThere's a few more examples in `EXAMPLES.md <EXAMPLES.md>`__\n\nCommand Line Args\n-----------------\n\n::\n\n    curlbomb [-h] [-n N] [-p PORT] [-d host[:port]] [-w] [-l] [-q] [-v]\n             [--ssh SSH_FORWARD] [--ssl CERTIFICATE] [--pin] [-e]\n             [--encrypt-to GPG_ID] [--passphrase] [--survey] [--unwrapped]\n             [--client-logging] [--client-quiet] [--mime-type MIME_TYPE]\n             [--disable-knock] [--knock KNOCK] [--version]\n             {run,put,get,ping,ssh-copy-id} ...\n                   \n\ncurlbomb has a few subcommands:\n\n-  ``run`` - run a shell script\n-  ``put`` - copy local files/directories to remote system\n-  ``get`` - copy remote files/directories to local system\n-  ``ping`` - wait for a client to finish a task, with optional\n   notification command\n-  ``ssh-copy-id`` - copy SSH public keys to the remote authorized\\_keys\n   file\n\nIf no subcommand is specified, and there is data being piped to stdin,\nthen the ``run`` subcommand is used implicitly.\n\nThe following arguments apply to all subcommands:\n~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\n``-n N, --num-gets N`` The maximum number of times the script may be\nfetched by clients, defaulting to 1. Increasing this may be useful in\ncertain circumstances, but please note that the same knock parameter is\nused for all requests so this is inherently less secure than the\ndefault. Setting this to 0 will allow the resource to be downloaded an\nunlimited number of times.\n\n``-p PORT`` The local TCP port number to use.\n\n``-d host[:port], --domain host[:port]`` Specify the domain name and\nport that is displayed in the URL of the client command. This does not\nchange where the resource is actually located, use --port or --ssh for\nthat. This is useful if you are setting up your own port forwards and\nneed to show an external URL.\n\n``-w, --wget`` Print wget syntax rather than curl syntax. Useful in the\ncase where the client doesn't have curl installed. Not compatible with\n``--log--posts`` or the ``put`` and ``get`` subcommands. :(\n\n``-l, --log-posts`` Log the client stdout to the server stdout.\n\n``-q, --quiet`` Be more quiet. Don't print the client curlbomb command.\n\n``-v, --verbose`` Be more verbose. Turns off ``--quiet``, enables\n``--log-posts``, and enables INFO level logging within curlbomb.\n\n``--ssh SSH_FORWARD`` Forwards the curlbomb server to a remote port of\nanother computer through SSH. This is useful to serve curlbombs to\nclients on another network without opening up any ports to the machine\nrunning curlbomb. The syntax for SSH\\_FORWARD is\n[user@]host[:ssh\\_port][:http\\_port]. The SSH server must have the\nGatewayPorts setting turned on to allow remote clients to connect to\nthis port. See sshd\\_config(5).\n\n``--ssl CERTIFICATE`` Run the HTTP server with TLS encryption. Provide\nthe full path to your SSL certificate, which may be PGP encrypted. The\nfile should contain the entire certificate chain, including the CA\ncertificate, if any. If the SSL certificate path is specified as ``-``,\na temporary self-signed certificate will be generated for the current\ncurlbomb session and ``--pin`` will be turned on implicitly.\n\n``--pin`` (requires curl>=7.39.0) Pin the SSL certificate fingerprint\ninto the client curl command. This is used to bypass the root CA store\nof the client machine, and to tell it exactly what the server's SSL\ncertificate looks like. This is useful for mitigating man-in-the-middle\nattacks, as well as when using self-signed certificates. This makes the\nclient command quite a bit longer than usual.\n\n``-e, --encrypt`` Encrypt the resource with gpg before serving it to the\nclient. A randomly generated symmetric passphrase will be printed below\nthe client command on the server. This passphrase must be input on the\nclient. You can specify the passphrase to use interactively with\n``--passphrase``. You can use public key encryption if you use\n``--encrypt-to``\n\n``--passphrase`` Encrypt the resource with a passphrase interactively\nasked on server start.\n\n``--encrypt-to GPG_ID`` Encrypt the resource with the given gpg\nidentity. Can be specified multiple times to encrypt to multiple\nrecipients.\n\n``--survey`` Only print the curl (or wget) command. Don't redirect to a\nshell command. Useful for testing script retrieval without running them.\n\n``--unwrapped`` output the full curlbomb command, including all the\nboilerplate that curlbomb normally wraps inside of a nested curlbomb.\n\nThis parameter is useful when you want to source variables into your\ncurrent shell:\n\n::\n\n    echo \"export PATH=/asdf/bin:$PATH\" | curlbomb -c source --unwrapped\n\nWithout the --unwrapped option, the client command will not run the\nsource command directly, but instead a bash script with a source inside\nit. This won't work for sourcing environment variables in your shell, so\nuse --unwrapped when you want to use source.\n\n``--client-logging`` Logs all client output locally on the client to a\nfile called curlbomb.log\n\n``--client-quiet`` Quiets the output on the client\n\n``--mime-type MIME_TYPE`` The mime-type header to send, by default\n\"text/plain\"\n\n``--disable-knock`` Don't require a X-knock HTTP header from the client.\nNormally, curlbombs are one-time-use and meant to be copy-pasted from\nterminal to terminal. If you're embedding into a script, you may not\nknow the knock parameter ahead of time and so this disables that. This\nis inherently less secure than the default.\n\n``--version`` Print the curlbomb version\n\nRun subcommand\n~~~~~~~~~~~~~~\n\n::\n\n    curlbomb run [-c COMMAND] [--hash SHA256] [--signature FILE_OR_URL [GPG_ID ...]] [SCRIPT]\n\nRuns a shell script on the remote client.\n\n``-c COMMAND`` Set the name of the command that the curlbomb is run with\non the client. By default, this is autodected from the first line of the\nscript, called the shebang (#!). If none can be detected, and one is not\nprovided by this setting, the fallback of \"bash\" is used. Note that\ncurlbomb will still wrap your script inside of bash, even with ``-c``\nspecified, so the client command will still show it as running in bash.\nThe command you specified is put into the wrapped script. See\n``--unwrapped`` to change this behaviour.\n\n``--hash SHA256`` Specify the expected SHA-256 hash of the script and\nthe server will verify that it actually has that hash before the server\nstarts. This is useful if you are pipeing a script from someplace\noutside of your control, like from the network. This prevents the server\nfrom serving a script other than the version you were expecting.\n\n``--signature FILE_OR_URL [GPG_ID ...]`` Specify the file or URL\ncontaining the GPG signature for the script. Optionally specify a list\nof GPG key identifiers that are allowed to sign the script. If no\nGPG\\_ID is specified, any valid signature from your keyring is accepted.\nThe script will be checked for a valid signature before the server\nstarts.\n\n``SCRIPT`` The script or other resource to serve via curlbomb. You can\nalso leave this blank (or specify '-') and the resource will be read\nfrom stdin.\n\nNote that the run subcommand is implied if you are pipeing data to\ncurlbomb. For instance, this command is assumed that the run command is\ndesired even if not explicitly used:\n\n::\n\n    echo \"./run_server.sh\" | curlbomb\n\nWhich is equivalent to:\n\n::\n\n    echo \"./run_server.sh\" | curlbomb run -\n\nPut subcommand\n~~~~~~~~~~~~~~\n\n::\n\n    curlbomb put [--exclude=PATTERN] SOURCE [DEST]\n\nCopies file(s) from the local SOURCE path to the remote DEST path. If a\ndirectory is specified, all child paths will be copied recursively.\n\nIf DEST path is unspecified, files/directories will be copied to the\nworking directory of wherever the client was run.\n\nExclude patterns can be specified like tar(1)\n\nGet subcommand\n~~~~~~~~~~~~~~\n\n::\n\n    curlbomb get [--exclude=PATTERN] SOURCE [DEST]\n\nCopies file(s) from the remote SOURCE path to the local DEST path. If a\ndirectory is specified, all child paths will be copied recursively.\n\nIf DEST path is unspecified, files/directories will be copied to the\nworking directory of wherever curlbomb was run.\n\nExclude patterns can be specified like tar(1)\n\nPing subcommand\n~~~~~~~~~~~~~~~\n\n::\n\n    curlbomb ping [-m MESSAGE] [-r RETURN_CODE] [--return-success]\n                  [-c COMMAND] [-n]\n\nServes an empty body resource for the purposes of pinging the server\nwhen the client has finished some task.\n\n``-m`` sets the message the client will respond with.\n\n``-r`` sets the return code the client will respond with. This is used\nas the main curlbomb return code on the server as well. If ``-n`` > 1,\nthe last non-zero return code received is used instead, defaulting to 0.\n\n``--return-success`` Always return 0, regardless of the return code(s)\nreceived.\n\n``-c COMMAND`` Run this command for each ping received. You can use the\nfollowing placeholders to format ping data: {return\\_code} and\n{message}. {message} is replaced surrounded by quotes, so no need to do\nthat again in your command.\n\nssh-copy-id subcommand\n~~~~~~~~~~~~~~~~~~~~~~\n\n::\n\n    curlbomb ssh-copy-id IDENTITY\n\nCopies the given OpenSSH identity file (eg. ~/.ssh/id\\_rsa.pub) into the\nremote ~/.ssh/authorized\\_keys file.\n\nOf course OpenSSH comes with it's own ssh-copy-id program, but I've\nnever really understood the usefulness of it. The idea of using SSH keys\nis to not use crappy passwords, right? But the OpenSSH version of\nssh-copy-id requires password authentication (at least temporarily\nduring the setup process.) So you either have to edit your sshd\\_config,\nturn on ``PasswordAuthentication``, and restart the service, or you\nresign yourself to run an insecure sshd all the time.\n``curlbomb ssh-copy-id`` is easier and works in more situations.\n\nAnother difference in this version is that you must explicity specify\nthe identity file, whereas the OpenSSH version does some automatic\ndetermination of which key to install. Especially if you maintain\nseveral ssh identities, being explicit seems the more sane thing to do\nthan try to save some keystrokes and inevitably install the wrong key on\nthe server.",
        "description_content_type": null,
        "docs_url": null,
        "download_url": "UNKNOWN",
        "downloads": {
            "last_day": -1,
            "last_month": -1,
            "last_week": -1
        },
        "home_page": "https://github.com/EnigmaCurry/curlbomb",
        "keywords": null,
        "license": "MIT",
        "maintainer": null,
        "maintainer_email": null,
        "name": "curlbomb",
        "package_url": "https://pypi.org/project/curlbomb/",
        "platform": "UNKNOWN",
        "project_url": "https://pypi.org/project/curlbomb/",
        "project_urls": {
            "Download": "UNKNOWN",
            "Homepage": "https://github.com/EnigmaCurry/curlbomb"
        },
        "release_url": "https://pypi.org/project/curlbomb/1.4.1/",
        "requires_dist": null,
        "requires_python": null,
        "summary": "A personal HTTP server for serving one-time-use shell scripts",
        "version": "1.4.1"
    },
    "last_serial": 2101336,
    "releases": {
        "1.0.10": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "b157034d324bf5526a08b7bafe9b7d4e",
                    "sha256": "40b5d74fbb816c1d498fb6594e5d7c079d801caf6ab83c3756a4715e28c89da0"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.10.tar.gz",
                "has_sig": false,
                "md5_digest": "b157034d324bf5526a08b7bafe9b7d4e",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 9010,
                "upload_time": "2016-03-25T21:02:44",
                "url": "https://files.pythonhosted.org/packages/00/4d/680d3ea3d65e2b7fb5c3b44b603a2294de9f781fefb8b3804cb25c42ee7e/curlbomb-1.0.10.tar.gz"
            }
        ],
        "1.0.11": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "de236e74a9aab9e5b0d30842ef087b6d",
                    "sha256": "f16731d0dbf0c609fa46be6c9b09f2cb7263c83e9f3204812d0dff831a158ff8"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.11.tar.gz",
                "has_sig": false,
                "md5_digest": "de236e74a9aab9e5b0d30842ef087b6d",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 9083,
                "upload_time": "2016-03-25T21:23:12",
                "url": "https://files.pythonhosted.org/packages/3d/6f/00c438844498ae5f183deff046bd3f5deacd18685e8575489583f95b991b/curlbomb-1.0.11.tar.gz"
            }
        ],
        "1.0.12": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "d7df9d9b6475cf6f40972e4a573cf3cf",
                    "sha256": "9e1369efa16eb87b7d6223bf987b54b72f5155d74bd63420feab0a6eaad97d58"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.12.tar.gz",
                "has_sig": false,
                "md5_digest": "d7df9d9b6475cf6f40972e4a573cf3cf",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 9125,
                "upload_time": "2016-03-25T21:37:11",
                "url": "https://files.pythonhosted.org/packages/f5/54/4b87f27dee5028ebc7b953d2b275c8b8d0a0be5bc1ba3ad053fc815d3bad/curlbomb-1.0.12.tar.gz"
            }
        ],
        "1.0.15": [],
        "1.0.16": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "7c4f9c822ad46c1a034f5146b3e2956d",
                    "sha256": "86f80ef13ee45b5931b2a775d80ceb8ea09e5cf4d67a9eec13776110d46a4ba5"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.16.tar.gz",
                "has_sig": false,
                "md5_digest": "7c4f9c822ad46c1a034f5146b3e2956d",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 11707,
                "upload_time": "2016-03-27T04:37:57",
                "url": "https://files.pythonhosted.org/packages/38/cb/beba11ca86d6c794c26532fb578d61e64e059f8723d9af570b8083f17a55/curlbomb-1.0.16.tar.gz"
            }
        ],
        "1.0.17": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "39908262790a80b2dabe929e7a73cb9f",
                    "sha256": "9bd5b575a890c674111ed47f6f2afd9f3a992b08db67b9a494a2c808d00e4985"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.17.tar.gz",
                "has_sig": false,
                "md5_digest": "39908262790a80b2dabe929e7a73cb9f",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 11492,
                "upload_time": "2016-03-27T04:47:35",
                "url": "https://files.pythonhosted.org/packages/9f/49/7ca1418bcf1d0717a48738901cf73dc9b350efefff1851bb04e8f231d655/curlbomb-1.0.17.tar.gz"
            }
        ],
        "1.0.5": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "bceb40dd02543516c9207f4105e76187",
                    "sha256": "e396a5ea24c08c6134bbaeb56a6e98f6a5ca1d5bdf8622080aa22b012af3cb94"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.5.tar.gz",
                "has_sig": false,
                "md5_digest": "bceb40dd02543516c9207f4105e76187",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 3543,
                "upload_time": "2016-03-25T02:38:35",
                "url": "https://files.pythonhosted.org/packages/ab/09/4d6ff1770c94d671db7ddac9554f867754711c00d3a55287718c6d4aeeab/curlbomb-1.0.5.tar.gz"
            }
        ],
        "1.0.6": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "5f02a2888bc5a734a4814e5948b3bdea",
                    "sha256": "47113984bd2e07d77ea3453ef3c9be31ee9f3ca30153199206f3fb38b86c9afc"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.6.tar.gz",
                "has_sig": false,
                "md5_digest": "5f02a2888bc5a734a4814e5948b3bdea",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 5295,
                "upload_time": "2016-03-25T03:11:35",
                "url": "https://files.pythonhosted.org/packages/f0/1d/5ab50bbfa744905e1b4528b3854c8e514dbc2e5b0b2d4edef3a21c845ebd/curlbomb-1.0.6.tar.gz"
            }
        ],
        "1.0.7": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "a87f761f5ec176ddccaaa90a0f0c3249",
                    "sha256": "f36df41ad1e90c53ee7fb45c53f0c065215d18814a7270c4788b59a90f8d98cb"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.7.tar.gz",
                "has_sig": false,
                "md5_digest": "a87f761f5ec176ddccaaa90a0f0c3249",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 6063,
                "upload_time": "2016-03-25T07:08:36",
                "url": "https://files.pythonhosted.org/packages/79/0e/97056dfcd86bd12ad2e200b66054529922f4989f8b1f6c748d32bcbaf8ee/curlbomb-1.0.7.tar.gz"
            }
        ],
        "1.0.8": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "40a643d403702d86a5c9b72a885c1194",
                    "sha256": "6cc3ddb69708b5a7c39417f487265b7ca6af778ae6d6ed1eb6c1993e8a8053d7"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.8.tar.gz",
                "has_sig": false,
                "md5_digest": "40a643d403702d86a5c9b72a885c1194",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 6746,
                "upload_time": "2016-03-25T07:37:04",
                "url": "https://files.pythonhosted.org/packages/a5/87/fa96c8000957d2c5a001b7f82c063cf168708df3b19433cc5cfa01f45136/curlbomb-1.0.8.tar.gz"
            }
        ],
        "1.0.9": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "a82e63a03c5c394f0a937e736db38e4f",
                    "sha256": "f648c5f4b48fc96ded9f8432049608362878a92480299e982945ee80be653779"
                },
                "downloads": -1,
                "filename": "curlbomb-1.0.9.tar.gz",
                "has_sig": false,
                "md5_digest": "a82e63a03c5c394f0a937e736db38e4f",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 7787,
                "upload_time": "2016-03-25T18:12:33",
                "url": "https://files.pythonhosted.org/packages/63/2a/65e19b499fab2717c64e15e2d4cbc1ba36c0099ac563619a4bb1f9cb49a7/curlbomb-1.0.9.tar.gz"
            }
        ],
        "1.1.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "18d7683d259a836aca491a95f37fc825",
                    "sha256": "71d58b0a3fdf016d4535f3cc594a14c62aa1bc286e93cf95abc8de19353d4ebb"
                },
                "downloads": -1,
                "filename": "curlbomb-1.1.0.tar.gz",
                "has_sig": false,
                "md5_digest": "18d7683d259a836aca491a95f37fc825",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 16356,
                "upload_time": "2016-03-31T19:51:19",
                "url": "https://files.pythonhosted.org/packages/76/95/ed64bb116f9da34a6d070c934af84c628f7390e49eaf68770cc94a7ac5fc/curlbomb-1.1.0.tar.gz"
            }
        ],
        "1.1.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "062b8a6efeb1a1d235382939803e2600",
                    "sha256": "e747a77c0d19ebc7d8d50c82067c24fc9d523b5f42ec497a2b914157d8b2f870"
                },
                "downloads": -1,
                "filename": "curlbomb-1.1.1.tar.gz",
                "has_sig": false,
                "md5_digest": "062b8a6efeb1a1d235382939803e2600",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 18130,
                "upload_time": "2016-04-01T02:12:01",
                "url": "https://files.pythonhosted.org/packages/43/20/e8c0d5b7b9f4df892630d79372106188f42fea2a325d5caadaa29f5ec21c/curlbomb-1.1.1.tar.gz"
            }
        ],
        "1.1.2": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "722d6da3e47a61743a0df6cd54bbab37",
                    "sha256": "49e78d1241a7fbd6767812f710f892dbb4c5f82535223c429a11e3152a2fc61f"
                },
                "downloads": -1,
                "filename": "curlbomb-1.1.2.tar.gz",
                "has_sig": false,
                "md5_digest": "722d6da3e47a61743a0df6cd54bbab37",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 18377,
                "upload_time": "2016-04-01T16:48:00",
                "url": "https://files.pythonhosted.org/packages/0f/52/2101a11b8a3be4c8a9ac47ed0dceeac0a5025de862e2fdc1796f2d270cb9/curlbomb-1.1.2.tar.gz"
            }
        ],
        "1.2.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "238032329eeec0c365dc76e13057294d",
                    "sha256": "78cb56ac298f461604da64214bcd654f0d181b59ddebd4a2c82bae18adce19be"
                },
                "downloads": -1,
                "filename": "curlbomb-1.2.0.tar.gz",
                "has_sig": false,
                "md5_digest": "238032329eeec0c365dc76e13057294d",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 22433,
                "upload_time": "2016-04-06T03:09:52",
                "url": "https://files.pythonhosted.org/packages/6a/32/074cbac19db0b498fb2c2e849f2e429dc483a0280511dc7def2bae71da98/curlbomb-1.2.0.tar.gz"
            }
        ],
        "1.3.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "2cd2c48f6f1bf91530da7f3bb18adab7",
                    "sha256": "4395a07402817f4107bc410a8149748f9085e654b085d6e59f3eeab5c4a8dca7"
                },
                "downloads": -1,
                "filename": "curlbomb-1.3.0.tar.gz",
                "has_sig": false,
                "md5_digest": "2cd2c48f6f1bf91530da7f3bb18adab7",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 30468,
                "upload_time": "2016-04-25T19:05:27",
                "url": "https://files.pythonhosted.org/packages/e2/7d/bb718da97006405a3fbc75a03fe51a92b142643517c0cc2c09155692b7b9/curlbomb-1.3.0.tar.gz"
            }
        ],
        "1.3.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "1c3df5046475e503dacd81f45a62e083",
                    "sha256": "110e24533c22b7386298bd9ccf6a9228088017e4598bec1865a1656d2679972d"
                },
                "downloads": -1,
                "filename": "curlbomb-1.3.1.tar.gz",
                "has_sig": false,
                "md5_digest": "1c3df5046475e503dacd81f45a62e083",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 37809,
                "upload_time": "2016-04-27T23:30:47",
                "url": "https://files.pythonhosted.org/packages/1d/c8/27fb878ae84d4c98c9b9fb3d91abef81a11f33ba7e4f3ca364209df83505/curlbomb-1.3.1.tar.gz"
            }
        ],
        "1.4.0": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "096bae423eb4bf680716b9715af6125f",
                    "sha256": "36f34ebe33d2ad27fcbefb666b768b5059252d70c9d734625682dab5d85f3ee3"
                },
                "downloads": -1,
                "filename": "curlbomb-1.4.0.tar.gz",
                "has_sig": false,
                "md5_digest": "096bae423eb4bf680716b9715af6125f",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 42407,
                "upload_time": "2016-05-05T17:52:02",
                "url": "https://files.pythonhosted.org/packages/a2/1f/68aa9f434ac7765d9f9fd7aaa2e80e7326bd94a0995631468cc6778de850/curlbomb-1.4.0.tar.gz"
            }
        ],
        "1.4.1": [
            {
                "comment_text": "",
                "digests": {
                    "md5": "b39197c2b9ea1362c387bfe6fc7e7e2c",
                    "sha256": "d99847608df566bc02fa64f127300fd3dbeba14c11b60d225272f21688be01f6"
                },
                "downloads": -1,
                "filename": "curlbomb-1.4.1.tar.gz",
                "has_sig": false,
                "md5_digest": "b39197c2b9ea1362c387bfe6fc7e7e2c",
                "packagetype": "sdist",
                "python_version": "source",
                "requires_python": null,
                "size": 42390,
                "upload_time": "2016-05-05T19:10:11",
                "url": "https://files.pythonhosted.org/packages/2a/1e/c6db152cd596aa31682c1e7126891209182503eaac902a63f46c36316c21/curlbomb-1.4.1.tar.gz"
            }
        ]
    },
    "urls": [
        {
            "comment_text": "",
            "digests": {
                "md5": "b39197c2b9ea1362c387bfe6fc7e7e2c",
                "sha256": "d99847608df566bc02fa64f127300fd3dbeba14c11b60d225272f21688be01f6"
            },
            "downloads": -1,
            "filename": "curlbomb-1.4.1.tar.gz",
            "has_sig": false,
            "md5_digest": "b39197c2b9ea1362c387bfe6fc7e7e2c",
            "packagetype": "sdist",
            "python_version": "source",
            "requires_python": null,
            "size": 42390,
            "upload_time": "2016-05-05T19:10:11",
            "url": "https://files.pythonhosted.org/packages/2a/1e/c6db152cd596aa31682c1e7126891209182503eaac902a63f46c36316c21/curlbomb-1.4.1.tar.gz"
        }
    ]
}