Example #1
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    key_type = ht.get_required(query, 'key_type')
    public_key = ht.get_required(query, 'public_key')
    revoke_date = ht.get_optional(query, 'revoke_date')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        public_key_hash = db.import_public_key(c, user_id, session_id, key_type, public_key, revoke_date)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok', 'public_key_hash' : public_key_hash})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #2
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    group_id = ht.get_required(query, 'group_id')
    use = ht.get_required(query, 'use')
    access = ht.get_required(query, 'access')
    public_key_hash = ht.get_required(query, 'public_key_hash')
    passphrase = ht.get_optional(query, 'passphrase')


    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        resp = db.change_group_access(c, user_id, session_id, node_name, group_id, use, access, public_key_hash, passphrase)

        db.commit(conn)

        raise ht.ok_json({'status' : 'ok', 'resp' : resp})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #3
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    public_key_hash  = ht.get_required(query, 'public_key_hash')
    passphrase = ht.get_required(query, 'passphrase')
    expire_time = ht.convert_int(ht.get_optional(query, 'expire_time'), 'expire_time')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.cache_passphrase(c, user_id, session_id, public_key_hash, passphrase, expire_time)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok'})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #4
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    method  = ht.get_required(query, 'method')
    password  = ht.get_optional(query, 'password')
    public_key_hash  = ht.get_optional(query, 'public_key_hash')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.set_password(c, user_id, session_id, method, password, public_key_hash)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok'})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #5
0
def delete_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    group_id = ht.get_required(query, 'group_id')
    owner_id = ht.get_required(query, 'owner_id')
    post_id = ht.get_required(query, 'post_id')
    passphrase = ht.get_optional(query, 'passphrase')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        resp = db.delete_post(c, user_id, session_id, node_name, group_id, owner_id, post_id, passphrase)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok', 'resp' : resp})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #6
0
def post_handler(environ):

    query = ht.parse_post_request(environ)

    user_id = ht.get_required(query, 'user_id')
    password = ht.get_required(query, 'password')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        session = db.create_local_user(c, user_id, password)

        cookies = Cookie.SimpleCookie()
        cookies['user_id'] = session['user_id']
        cookies['user_id']['path'] = '/'
        cookies['session_id'] = session['session_id']
        cookies['session_id']['path'] = '/'

        db.commit(conn)

        raise ht.ok_json({'status' : 'ok', 'session' : session}).attach_cookies(cookies)

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #7
0
def delete_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    other_user_id = ht.get_required(query, 'other_user_id')
    node_name = ht.get_required(query, 'node_name')
    public_key_hash = ht.get_required(query, 'public_key_hash')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.delete_other_user_key(c, user_id, session_id, other_user_id, node_name, public_key_hash)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok'})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #8
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, "user_id")
    session_id = ht.get_required_cookie(cookies, "session_id")

    group_id = ht.get_required(query, "group_id")
    owner_id = ht.get_required(query, "owner_id")
    node_name = ht.get_required(query, "node_name")
    key_use = ht.get_required(query, "key_use")
    public_key_hash = ht.get_required(query, "public_key_hash")

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.assign_local_group_key(c, user_id, session_id, group_id, owner_id, node_name, key_use, public_key_hash)
        db.commit(conn)

        raise ht.ok_json({"status": "ok"})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #9
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    url = ht.get_required(query, 'url')
    real_node_name = ht.get_required(query, 'real_node_name')
    fingerprint = ht.get_optional(query, 'fingerprint')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.set_node_addr(c, user_id, session_id, node_name, url, real_node_name, fingerprint)

        db.commit(conn)

        raise ht.ok_json({'status' : 'ok'})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #10
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    group_id = ht.get_required(query, 'group_id')
    owner_id = ht.get_required(query, 'owner_id')
    node_name = ht.get_required(query, 'node_name')
    use = ht.get_required(query, 'use')
    access = ht.get_required(query, 'access')
    timestamp = ht.get_optional(query, 'timestamp')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.set_local_group_access(c, user_id, session_id, group_id, owner_id, node_name, use, access, timestamp)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok'})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #11
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    new_size = ht.convert_int(ht.get_required(query, 'new_size'), 'new_size')
    when_space_exhausted = ht.get_required(query, 'when_space_exhausted')
    public_key_hash = ht.get_required(query, 'public_key_hash')
    passphrase = ht.get_optional(query, 'passphrase')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        resp = db.change_message_quota(c, user_id, session_id,
                                       node_name, new_size, when_space_exhausted,
                                       public_key_hash, passphrase)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok', 'resp' : resp})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #12
0
def delete_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    to_user = ht.get_required(query, 'to_user')
    node_name = ht.get_required(query, 'node_name')
    from_user_key_hash = ht.get_required(query, 'from_user_key_hash')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.delete_local_message_access(c, user_id, session_id, to_user, node_name, from_user_key_hash)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok'})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #13
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    group_id = ht.get_required(query, 'group_id')
    post_access = ht.get_required(query, 'post_access')
    read_access = ht.get_required(query, 'read_access')
    delete_access = ht.get_required(query, 'delete_access')
    posting_key_hash = ht.get_optional(query, 'posting_key_hash')
    reading_key_hash = ht.get_optional(query, 'reading_key_hash')
    delete_key_hash = ht.get_optional(query, 'delete_key_hash')
    quota_allocated = ht.convert_int(ht.get_required(query, 'quota_allocated'), 'quota_allocated')
    when_space_exhausted = ht.get_required(query, 'when_space_exhausted')
    max_post_size = ht.convert_int(ht.get_optional(query, 'max_post_size'), 'max_post_size')
    public_key_hash = ht.get_required(query, 'public_key_hash')
    passphrase = ht.get_optional(query, 'passphrase')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        resp = db.create_group(c, user_id, session_id,
                               node_name, group_id,
                               post_access, read_access, delete_access,
                               posting_key_hash, reading_key_hash, delete_key_hash,
                               quota_allocated, when_space_exhausted,
                               max_post_size,
                               public_key_hash, passphrase)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok', 'resp' : resp})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #14
0
def get_handler(environ):

    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        db.sign_out(c, user_id, session_id)
        db.commit(conn)

        cookies = ['user_id', 'session_id']

        raise ht.ok_json({'status' : 'ok'}).clear_cookies(cookies)

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #15
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    to_user = ht.get_required(query, 'to_user')
    to_user_key_hash = ht.get_optional(query, 'to_user_key_hash')
    from_user_key_hash = ht.get_optional(query, 'from_user_key_hash')
    message  = ht.get_required(query, 'message')
    passphrase = ht.get_optional(query, 'passphrase')
    force_encryption = ht.convert_bool(ht.get_optional(query, 'force_encryption'), 'force_encryption')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        resp, local_gen = db.send_message(c, user_id, session_id,
                                          node_name, to_user, to_user_key_hash, from_user_key_hash,
                                          message, passphrase, force_encryption)
        (message_id, timestamp, message_hash, from_signature, proof_of_work) = local_gen

        db.commit(conn)

        raise ht.ok_json({'status' : 'ok',
                          'resp' : resp,
                          'message_id' : message_id,
                          'timestamp' : timestamp,
                          'message_hash' : message_hash,
                          'from_signature' : from_signature,
                          'proof_of_work' : proof_of_work})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #16
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    group_id = ht.get_required(query, 'group_id')
    owner_id = ht.get_required(query, 'owner_id')
    data = ht.get_required(query, 'data')
    passphrase = ht.get_optional(query, 'passphrase')
    force_encryption = ht.convert_bool(ht.get_optional(query, 'force_encryption'), 'force_encryption')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        resp, local_gen = db.make_post(c, user_id, session_id, node_name, group_id, owner_id, data,
                                       passphrase, force_encryption)

        (post_id, timestamp, data_hash, post_signature, proof_of_work) = local_gen

        db.commit(conn)

        raise ht.ok_json({'status' : 'ok',
                          'resp' : resp,
                          'post_id' : post_id,
                          'timestamp' : timestamp,
                          'data_hash' : data_hash,
                          'post_signature' : post_signature,
                          'proof_of_work' : proof_of_work})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #17
0
def post_handler(environ):

    query = ht.parse_post_request(environ)
    cookies = ht.parse_cookies(environ)

    user_id = ht.get_required_cookie(cookies, 'user_id')
    session_id = ht.get_required_cookie(cookies, 'session_id')

    node_name = ht.get_required(query, 'node_name')
    public_key_hash = ht.get_required(query, 'public_key_hash')
    default_message_access = ht.get_required(query, 'default_message_access')
    when_mail_exhausted = ht.get_required(query, 'when_mail_exhausted')
    quota_size = ht.convert_int(ht.get_required(query, 'quota_size'), 'quota_size')
    mail_quota_size = ht.convert_int(ht.get_required(query, 'mail_quota_size'), 'mail_quota_size')
    max_message_size = ht.convert_int(ht.get_optional(query, 'max_message_size'), 'max_message_size')
    user_class = ht.get_optional(query, 'user_class')
    auth_token = ht.get_optional(query, 'auth_token')

    conn = db.connect(config.db_path)
    try:
        c = db.cursor(conn)
        resp = db.create_user(c, user_id, session_id,
                              node_name, public_key_hash,
                              default_message_access, when_mail_exhausted,
                              quota_size, mail_quota_size,
                              max_message_size,
                              user_class, auth_token)
        db.commit(conn)

        raise ht.ok_json({'status' : 'ok', 'resp' : resp})

    except ex.SqueakException as e:
        raise ht.convert_squeak_exception(e)

    finally:
        db.close(conn)
Example #18
0
#!/usr/bin/python
# Run this script as user: www-data

import proxy_path
import squeakspace.proxy.server.db_sqlite3 as db
import config
import os

try:
    os.remove(config.db_path)
except OSError:
    pass
        
conn = db.connect(config.db_path)
c = db.cursor(conn)
db.make_db(c)
db.commit(conn)
db.close(conn)