def test_bytes_password(self):
     ptext = decrypt(b'password', encrypt(b'password', b'message'))
     assert ptext == b'message', ptext
     ptext = decrypt('password', encrypt(b'password', b'message'))
     assert ptext == b'message', ptext
     ptext = decrypt(b'password', encrypt('password', b'message'))
     assert ptext == b'message', ptext

def save_db(creds, password=''):
  creds['password'] = password and hexlify(encrypt(password, creds['password'])) or creds['password']
  creds['username'] = password and hexlify(encrypt(password, creds['username'])) or creds['username']
  keychain = Keychain()
  account = getlogin()
  password = "%s%s%s" % (creds['username'], JOIN_STRING, creds['password'])
  return keychain.set_generic_password(KEYCHAIN, account, password, SERVICE_NAME)

def config_taskstore():
    if len(sys.argv) < 5:
        print('''Usage for configure taskstore.ini for database connection:
            python taskstore.py host user password database
            python taskstore.py host user password database encrypt_key

            Example:
                python taskstore.py 172.16.16.16 root xFGt3Swq test
                (Encrypt key will be taken from environment)
                python taskstore.py 172.16.16.16 root xFGt3Swq test MyEncrYptKey
                (Encrypt key taken from param)
              ''')
        sys.exit(1)
    host = sys.argv[1]
    user = sys.argv[2]
    password = sys.argv[3]
    db = sys.argv[4]
    if len(sys.argv) == 5:
        secret = os.getenv('SECRET_KEY', 'my_secret_key') #get secret from env
    else:
        secret = sys.argv[5] #get secret by param
    current_path = os.path.dirname(os.path.realpath(__file__))
    newfile = os.path.join(current_path, 'taskstore.ini')
    with open(newfile, 'w') as f:
        f.write('[db_connection]\n')
        f.write('host='+base64.b64encode(encrypt(secret, host))+'\n')
        f.write('user='+base64.b64encode(encrypt(secret, user))+'\n')
        f.write('password='+base64.b64encode(encrypt(secret, password))+'\n')
        f.write('db='+base64.b64encode(encrypt(secret, db)))
        print('done')

 def test_unicode_plaintext(self):
     ptext = decrypt(u'password', encrypt(u'password', u'message'))
     assert ptext.decode('utf8') == 'message', ptext
     ptext = decrypt(u'password', encrypt(u'password', u'message'.encode('utf8')))
     assert ptext == 'message'.encode('utf8'), ptext
     ptext = decrypt(u'password', encrypt(u'password', u'¥£€$¢₡₢₣₤₥₦₧₨₩₪₫₭₮₯₹'))
     assert ptext.decode('utf8') == u'¥£€$¢₡₢₣₤₥₦₧₨₩₪₫₭₮₯₹', ptext
     ptext = decrypt(u'password', encrypt(u'password', u'¥£€$¢₡₢₣₤₥₦₧₨₩₪₫₭₮₯₹'.encode('utf8')))
     assert ptext == u'¥£€$¢₡₢₣₤₥₦₧₨₩₪₫₭₮₯₹'.encode('utf8'), ptext

def right():
    plaintext = 'hello world'

    key = 'python'
    ciphertext = encrypt(key, plaintext)
    print ciphertext

    key = 'password'
    ciphertext = encrypt(key, plaintext)
    print ciphertext

    plaintext = decrypt(key, ciphertext)
    print plaintext

def send_broadcast(request):
    if request.method == 'POST':
        form = BroadcastForm(request.POST)

        # validation checking...
        if form.is_valid():
            sender = request.user

            subject = request.POST['subject']
            text = request.POST['body']
            encrypted = request.POST.get('encrypted', False)
            enc_key = request.POST['enc_key']
            raw_b = b""

            if enc_key == "":
                enc_key = "N/A"
            else:

                #encrypt
                #encrypt
                raw_b = encrypt(enc_key, text)
                text=str(raw_b)

            pm_broadcast(sender,"", subject, encrypted, raw=raw_b, body=text)
            return render(request, 'postman/inbox.html', )
        else:
            return render(request, 'broadcast.html', {'message_form': form})


    else:
        form = BroadcastForm()
        return render(request, 'broadcast.html', {'message_form': form})

    def post(self):
        auth_code = self.request.get('code')
        auth_header = "Basic " + base64.b64encode(k_client_id + b":" + k_client_secret)
        params = {
            "grant_type": "authorization_code",
            "redirect_uri": k_client_callback_url,
            "code": auth_code
        }
        encoded_params = urllib.urlencode(params)

        response = urlfetch.fetch(url=k_spotify_accounts_endpoint + "/api/token",
                                  payload=encoded_params,
                                  method=urlfetch.POST,
                                  headers={"Authorization": auth_header},
                                  validate_certificate=True)

        if response.status_code == 200:
            token_data = json.loads(response.content)
            refresh_token = token_data["refresh_token"]
            encrypted_token = simplecrypt.encrypt(k_encryption_secret, refresh_token)
            base64_encrypted_token = base64.encodestring(encrypted_token)
            token_data["refresh_token"] = base64_encrypted_token
            response.content = json.dumps(token_data)

        self.response.headers.add_header("Access-Control-Allow-Origin", '*')
        self.response.headers['Content-Type'] = 'application/json'
        self.response.status = response.status_code
        self.response.write(response.content)

 def click_save(self):
     raw_text = self.textEdit.toPlainText()
     t=unicode(raw_text)
     ciphertext = encrypt('123', t)
     self.content.text = hexlify(ciphertext)
     self.content.save()
     self.textEdit.clear

def dataproxy_resource_update(context, data_dict=None):
    """
    Intercepts default resource_update action and encrypts password for dataproxy type resources
    Args:
        context: Request context.
        data_dict: Parsed request parameters.
    Returns:
        see get_action('resource_update').
    Raises:
        Exception: if ckan.dataproxy.secret configuration not set.
    """
    #If not set, default to empty string
    data_dict['url_type'] = data_dict.get('url_type', '')
    url_type = data_dict['url_type']

    if url_type == 'dataproxy':
        secret = config.get('ckan.dataproxy.secret', False)
        if not secret:
            raise Exception('ckan.dataproxy.secret must be defined to encrypt passwords')
        #replace password with a _password_ placeholder
        password = data_dict.get('db_password', '')
        if password == '':
            #we don't want to overwrite existing password with empty string
            resource = Resource.get(data_dict['id'])
            data_dict['db_password'] = resource.extras['db_password']
        else:
            data_dict['url'] = data_dict['url'].replace(password, '_password_')
            #encrypt db_password
            data_dict['db_password'] = hexlify(encrypt(secret, password))

    site_url = config.get('ckan.site_url', '127.0.0.1')
    data_dict['url'] = '{0}/api/3/action/datastore_search?resource_id={1}&downloaded=true'.format(site_url, data_dict['id'])

    return orig_resource_update(context, data_dict)

def main(key, password):
    print 'Uses aes encryption'
    print 'Key: %s Password: %s' % (key, password)
    encrypt_one = encrypt(key, password)  # python string
    encrypt_two = encrypt(key, unicode(password))  # unicode
    encrypt_three = encrypt(key, password.encode('utf8'))  # utf8
    print 'encrypt_one: %s' % hexlify(encrypt_one)
    print 'encrypt_twp: %s' % hexlify(encrypt_two)
    print 'encrypt_three: %s' % hexlify(encrypt_three)
    print '\nEven though the key and password are the same'
    print 'Encoding matters'
    print 'encrypt_one == encrypt_two', encrypt_one == encrypt_two
    print 'encrypt_one == encrypt_three', encrypt_one == encrypt_three
    print 'encrypt_two == encrypt_three', encrypt_two == encrypt_three
    print '\nThe following will be the same for all 3'
    print 'plaintext: %s' % decrypt(key, encrypt_one)

def submitEmailPassword():

    for k in request.forms.keys():
        print k, request.forms[k]

    username = request.forms.get('email')
    password = request.forms.get('password')

    password_hashed = base64.urlsafe_b64encode(pbkdf2_sha256.encrypt(password, rounds=NOF_HASH_ROUNDS, salt_size=16))

    username_encrypted = base64.urlsafe_b64encode(encrypt(ENCRYPTION_PASSWORD, username))

    usersTable = db.table('users')

    existingUser = usersTable.search(where('key') == username_encrypted)
    if existingUser:
        if pbkdf2_sha256.verify(existingUser['values']['password'],password_hashed):
            pass
        else:
            print "wrong login"
    else:
        usersTable.insert({'key':username_encrypted, 'values':{'password':password_hashed}})
        videosTable = db.table('videos')
        existing_cookie = request.get_cookie('sebifyme',secret=GLOBAL_COOKIE_SECRET)
        uid = existing_cookie['uid']
        elements = videosTable.search((where('values').has('uploaded_by_uid') == uid) & (where('values').has('uploaded_by_user') == None))
        for el in elements:
            currentValues = el['values']
            currentValues['uploaded_by_user'] = username_encrypted
            videosTable.update({'values':currentValues}, eids=[el.eid])

    website_content = template('video',video_name='joke.mp4')

    return website_content

def create_config(project_dir, encrypt_pass='None'):

    config_dir = '%s/.config' % project_dir
    f = open(config_dir, 'w')

    print
    print '------Welcome to DataTools Configuration---------'
    print
    print 'Select SQL Flavor'
    print '[1] - SQLite'
    print '[2] - MySQL'
    flavor = int(raw_input('Input Number: '))
    print

    if flavor == 1:

        info = 'sqlite'
        info += ':%s.db' % raw_input('Database Name: ')

    elif flavor == 2:

        info = 'mysql'
        info += ':%s' % raw_input('Host: ')
        info += ':%s' % raw_input('Username: ')
        info += ':%s' % raw_input('Password: ')
        info += ':%s' % raw_input('Database Name: ')

    print
    print 'Encrypting Config File'
    f.write(encrypt(encrypt_pass, info))
    print 'Config File Complete'

def encrypt_fn(destroy_this):
    password = password_var_enc.get()
    password_conf = password_var_con.get()

    if password == password_conf:


        ciphertext = encrypt(password, private_key_readable)

        pem_file = open("privkey_encrypted.der", 'wb')
        pem_file.write(base64.b64encode(ciphertext))
        pem_file.close()

        encrypt_b.configure(text="Encrypted", state=DISABLED)
        destroy_this.destroy()
        os.remove("privkey.der")
        lock_b.configure(text="Lock", state=NORMAL)
    else:
        mismatch = Toplevel()
        mismatch.title("Bismuth")

        mismatch_msg = Message(mismatch, text="Password mismatch", width=100)
        mismatch_msg.pack()

        mismatch_button = Button(mismatch, text="Continue", command=mismatch.destroy)
        mismatch_button.pack(padx=15, pady=(5, 5))

def dataproxy_resource_create(context, data_dict=None):
    """
    Intercepts default resource_create action and encrypts password if resource is dataproxy type
    Args:
        context: Request context.
        data_dict: Parsed request parameters.
    Returns:
        see get_action('resource_create').
    Raises:
        Exception: if ckan.dataproxy.secret configuration not set.
    """
    #If not set, default to empty string
    url_type = data_dict.get('url_type')

    if url_type == 'dataproxy':
        secret = config.get('ckan.dataproxy.secret', False)
        if not secret:
            raise Exception('ckan.dataproxy.secret must be defined to encrypt passwords')
        password = data_dict.get('db_password')
        #replace password with a _password_ placeholder
        data_dict['url'] = 'tmpURL' #data_dict['url'].replace(password, '_password_')
        #encrypt db_password
        data_dict['db_password'] = hexlify(encrypt(secret, password))

    data_dict = orig_resource_create(context, data_dict)

    site_url = config.get('ckan.site_url', '127.0.0.1')
    data_dict['url'] = '{0}/api/3/action/datastore_search?resource_id={1}&downloaded=true'.format(site_url, data_dict['id'])

    return orig_resource_update(context, data_dict)

def createorder(myidhash, mybtc, offer, cryptkey, tx_fee, retries=0):
    price = decimal.Decimal(offer.obj['price'])
    try:
        pubkey = btcd.validateaddress(mybtc)['pubkey']
        multisig = btcd.createmultisig( 2, sorted([offer.obj['pubkey'], pubkey]) )
        change_addr = btcd.getrawchangeaddress()
    except httplib.BadStatusLine:
        reconnect_btcd(retries)
        return createorder(myidhash, mybtc, offer, cryptkey, tx_fee, retries+1)
    
    def create_funding(fee, retries=0):
        rawtx_hex = mktx(price, multisig['address'], change_addr, fee)
        try:
            return btcd.signrawtransaction(rawtx_hex)['hex']
        except httplib.BadStatusLine:
            reconnect_btcd(retries)
            return create_funding(fee, retries+1)
    
    signedtx_hex = create_funding(tx_fee)
    crypttx = base64.b64encode( simplecrypt.encrypt(cryptkey, signedtx_hex) )
    
    try:
        signedtx = btcd.decoderawtransaction(signedtx_hex)
    except httplib.BadStatusLine:
        reconnect_btcd(retries)
        return createorder(myidhash, mybtc, offer, cryptkey, tx_fee, retries+1)
    
    vout = searchtxops(signedtx, multisig['address'], price)
    
    return createordermsgstr(mybtc, offer.hash, offer.obj['vendorid'], myidhash, \
                                        pubkey, multisig, crypttx, signedtx['txid'], \
                                        vout, signedtx['vout'][vout]['scriptPubKey']['hex'] )

def dataproxy_resource_create(context, data_dict=None):
    """
    Intercepts default resource_create action and encrypts password if resource is dataproxy type
    Args:
        context: Request context.
        data_dict: Parsed request parameters.
    Returns:
        see get_action('resource_create').
    Raises:
        Exception: if ckan.dataproxy.secret configuration not set.
    """
    #If not set, default to empty string
    url_type = data_dict.get('url_type')

    if url_type == 'dataproxy':
        secret = config.get('ckan.dataproxy.secret', False)
        if not secret:
            raise Exception('ckan.dataproxy.secret must be defined to encrypt passwords')
        password = data_dict.get('db_password')
        #replace password with a _password_ placeholder
        data_dict['url'] = data_dict['url'].replace(password, '_password_')
        #encrypt db_password
        data_dict['db_password'] = hexlify(encrypt(secret, password))

    return orig_resource_create(context, data_dict)

 def encrypt_store_data(self, crypt_file_path, password, idea_collection):
     self.screenmanager.clear_widgets()
     ser_data = jsonpickle.encode(idea_collection)
     enc_data = simplecrypt.encrypt(password, ser_data)
     with open(crypt_file_path, 'wb') as f:
         f.write(enc_data)
     self.stop()

 def test_bad_password(self):
     ctext = bytearray(encrypt('password', 'message'))
     try:
         decrypt('badpassword', ctext)
         assert False, 'expected error'
     except DecryptionException as e:
         assert 'Bad password' in str(e), e

 def test_unicode_plaintext(self):
     def u(string):
         u_type = type(b''.decode('utf8'))
         if not isinstance(string, u_type):
             return string.decode('utf8')
         return string
     u_message = u('message')
     u_high_order = u('¥£€$¢₡₢₣₤₥₦₧₨₩₪₫₭₮₯₹')
     ptext = decrypt('password', encrypt('password', u_message))
     assert ptext.decode('utf8') == 'message', ptext
     ptext = decrypt('password', encrypt('password', u_message.encode('utf8')))
     assert ptext == 'message'.encode('utf8'), ptext
     ptext = decrypt('password', encrypt('password', u_high_order))
     assert ptext.decode('utf8') == u_high_order, ptext
     ptext = decrypt('password', encrypt('password', u_high_order.encode('utf8')))
     assert ptext == u_high_order.encode('utf8'), ptext

def encode(msg, m_file, passwd=None):
    """This functions encodes the given secret into a destination file.

    Args:
        msg (str): For encoding commands the message or text file to encode
                   For decoding commands the file to decode

        m_file (str): For encoding commands the file in which the message will be encoded
                   For decoding commands the password to decrypt the message

    Kwargs:
        password (str): For encoding commands the password to encrypt the message

    """
    secret = get_secret_msg(msg)

    #Convert the destination file into hex so that we can measure its free space
    with open(m_file, "rb") as dest_file:
        destination = dest_file.read()

    if passwd is not None:
        from simplecrypt import encrypt
        secret = encrypt(passwd, secret)

    msg_chars = len(secret)
    secret = secret.encode('hex')
    destination = destination.encode('hex')
    #At this point 'secret'(str) and 'destination'(file) are now hex values(str)

    #Free space in the destination is currently defined as spaces
    #We decide if there is enough blank space to just plug in the secret message
    free_space = size_of_free_space(destination)
    write_steganized_output_file(free_space, msg_chars, m_file, secret, destination)