from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import CHARSET_DIR
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.charset.argumentsParser import updateCharset_parser
from src.api.fitcrack.endpoints.charset.responseModels import charset_model, charsetCollection_model
from src.api.fitcrack.functions import fileUpload
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcCharset
from base64 import b64encode
log = logging.getLogger(__name__)
ns = api.namespace('charset',
description='Endpoints for work with charset files.')
ALLOWED_EXTENSIONS = set(['txt', 'hcchr', 'charset'])
@ns.route('')
class charsetCollection(Resource):
@api.marshal_with(charsetCollection_model)
def get(self):
"""
Ruturns collection of HcStats files.
"""
return {
'items': FcCharset.query.filter(FcCharset.deleted == False).all()
}
from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import RULE_DIR
from src.api.apiConfig import api
from src.api.fitcrack.argumentsParser import pagination
from src.api.fitcrack.endpoints.markov.responseModels import hcStatsCollection_model
from src.api.fitcrack.endpoints.rule.argumentsParser import updateRule_parser, rule_parser
from src.api.fitcrack.endpoints.rule.responseModels import rule_model, ruleData_model
from src.api.fitcrack.functions import fileUpload
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcRule
log = logging.getLogger(__name__)
ns = api.namespace(
'rule', description='Endpointy ktoré slúžia na pracu s rule subormi.')
ALLOWED_EXTENSIONS = set(['txt', 'rule'])
@ns.route('')
class ruleCollection(Resource):
@api.marshal_with(simpleResponse)
def post(self):
"""
Nahrava rule subor na server
"""
# check if the post request has the file part
if 'file' not in request.files:
abort(500, 'No file part')
return redirect(request.url)
'''
* Author : see AUTHORS
* Licence: MIT, see LICENSE
'''
import logging
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.status.responseModels import JobStatusCollection_model
from src.database.models import FcJobStatus
log = logging.getLogger(__name__)
ns = api.namespace('status',
description='Endpoints for reading changes in job status.')
@ns.route('')
class statusCollection(Resource):
@api.marshal_with(JobStatusCollection_model)
def get(self):
"""
Returns collection of all job statuses.
"""
return {'items': FcJobStatus.query.all()}
@ns.route('/<id>')
class statusCollection(Resource):
@api.marshal_with(JobStatusCollection_model)
import json
from flask import request
from flask_restplus import Resource, abort
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.bins.responseModels import bin_model, bin_with_jobs_model, bins_model
from src.api.fitcrack.endpoints.bins.argumentsParser import name, position, job_assignment
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcBin, FcJob
log = logging.getLogger(__name__)
ns = api.namespace('bins', description='Endpoints for job bins.')
@ns.route('')
class bins(Resource):
@api.expect(name)
@api.response(201, 'Created')
@api.response(500, 'Failed')
def post(self):
"""
Add a named job bin.
"""
data = request.json
bin = FcBin(name=data['name'])
try:
db.session.add(bin)
from flask import request, redirect, send_from_directory
from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import PROTECTEDFILES_DIR
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.protectedFile.functions import getHashFromFile
from src.api.fitcrack.endpoints.protectedFile.responseModels import protectedFilesCollection_model, \
excryptedFileUploaded_model
from src.api.fitcrack.functions import fileUpload
from src.database import db
from src.database.models import FcEncryptedFile
log = logging.getLogger(__name__)
ns = api.namespace(
'protectedFiles',
description='Endpointy ktoré slúžia na pracu so zaheslovanými súbormi.')
ALLOWED_EXTENSIONS = set(
["doc", "docx", "xls", "xlsx", "ppt", "pptx", "pdf", "rar", "zip", "7z"])
@ns.route('/')
class filesCollection(Resource):
@api.marshal_with(protectedFilesCollection_model)
def get(self):
"""
Vracia kolekciu zaheslovaných suborov
"""
return {'items': FcEncryptedFile.query.all()}
import os
from flask import request, redirect, send_file
from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import PROTECTEDFILES_DIR
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.protectedFile.functions import getHashFromFile
from src.api.fitcrack.endpoints.protectedFile.responseModels import protectedFilesCollection_model, \
excryptedFileUploaded_model
from src.api.fitcrack.functions import fileUpload
from src.database import db
from src.database.models import FcEncryptedFile
log = logging.getLogger(__name__)
ns = api.namespace('protectedFiles', description='Endpoints for operations with files with passwords.')
ALLOWED_EXTENSIONS = set(["doc", "docx", "xls", "xlsx", "ppt", "pptx", "pdf", "rar", "zip", "7z"])
@ns.route('/')
class filesCollection(Resource):
@api.marshal_with(protectedFilesCollection_model)
def get(self):
"""
Returns collection of hashed files.
"""
return {'items': FcEncryptedFile.query.all()}
@ns.route('/add')
from flask import request
from flask_login import login_user, logout_user, current_user, LoginManager
from flask_restplus import Resource, abort
from sqlalchemy import exc
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.user.argumentsParser import user_login_arguments, change_user_role_arguments, \
change_role_arguments, new_role_arguments, new_user_arguments, user_change_password_arguments
from src.api.fitcrack.endpoints.user.responseModels import fc_user_model, isLoggedIn_model, role_list_model, \
user_list_model, userSuccessResponse_model
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcUser, FcRole, AnonUser
log = logging.getLogger(__name__)
ns = api.namespace('user', description='Endpoints for authorization.')
login_manager = LoginManager()
login_manager.anonymous_user = AnonUser
@login_manager.user_loader
def load_user(user_id):
return FcUser.query.get(int(user_id))
@ns.route('/')
class userCollection(Resource):
@api.marshal_with(user_list_model)
def get(self):
"""
from flask import request
from flask_login import login_user, logout_user, current_user, LoginManager
from flask_restplus import Resource, abort
from sqlalchemy import exc
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.user.argumentsParser import user_login_arguments, change_user_role_arguments, \
change_role_arguments, new_role_arguments, new_user_arguments
from src.api.fitcrack.endpoints.user.responseModels import fc_user_model, isLoggedIn_model, role_list_model, \
user_list_model
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcUser, FcRole, AnonUser
log = logging.getLogger(__name__)
ns = api.namespace('user', description='Endpointy ktoré slúžia na autorizáciu')
login_manager = LoginManager()
login_manager.anonymous_user = AnonUser
@login_manager.user_loader
def load_user(user_id):
return FcUser.query.get(int(user_id))
@ns.route('/')
class userCollection(Resource):
@api.marshal_with(user_list_model)
def get(self):
"""
'''
* Author : see AUTHORS
* Licence: MIT, see LICENSE
'''
import logging
from flask_restplus import Resource
from flask import request
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.logs.argumentsParser import newLogs_argument, logs_argument
from src.api.fitcrack.endpoints.logs.functions import log_parser
from src.api.fitcrack.endpoints.logs.responseModels import logsCollection_model
from src.api.fitcrack.functions import shellExec
log = logging.getLogger(__name__)
ns = api.namespace('log', description='Endpoints for log operations.')
@ns.route('')
class logs(Resource):
@api.expect(logs_argument)
@api.marshal_with(logsCollection_model)
def get(self):
"""
Returns logs.
"""
args = logs_argument.parse_args(request)
skip = args.get('skip_count', 0)
lastLog = args.get('last_log', None)
while True:
logs = shellExec(
from flask_restplus import Resource, abort
from sqlalchemy import exc
from werkzeug.utils import secure_filename
from settings import HASHCAT_UTILS_PATH, EXE_OR_BIN, HCSTATS_DIR, DICTIONARY_DIR
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.markov.argumentsParser import makeMarkovFromDictionary_parser
from src.api.fitcrack.endpoints.markov.responseModels import hcStatsCollection_model
from src.api.fitcrack.endpoints.pcfg.functions import extractNameFromZipfile
from src.api.fitcrack.functions import fileUpload, shellExec
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcHcstat, FcDictionary
log = logging.getLogger(__name__)
ns = api.namespace('markovChains',
description='Endpoints for work with HcStats files.')
ALLOWED_EXTENSIONS = set(['hcstat2'])
@ns.route('')
class markovCollection(Resource):
@api.marshal_with(hcStatsCollection_model)
def get(self):
"""
Returns collection of HcStats files.
"""
return {
'items': FcHcstat.query.filter(FcHcstat.deleted == False).all()
}
import logging
from flask import request
from flask_login import current_user, login_required
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.notifications.argumentsParser import notifications_parser
from src.api.fitcrack.endpoints.notifications.functions import getNotifications
from src.api.fitcrack.endpoints.notifications.responseModels import page_of_notifications_model, \
notification_count_model
from src.database.models import FcNotification
log = logging.getLogger(__name__)
ns = api.namespace('notifications',
description='Endpointy ktoré slúžia na vypisovanie grafov')
@ns.route('')
class notifications(Resource):
@api.expect(notifications_parser)
@api.marshal_with(page_of_notifications_model)
def get(self):
"""
Vráti uživateľove notifikácie
"""
args = notifications_parser.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
markAsSeen = args.get('seen', True)
import logging
import os
from pathlib import Path
from flask_restplus import Resource, abort
from flask import request
from settings import SERVER_BROWSER_ROOT as prefix
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.directory.argumentsParser import directory_parser
from src.api.fitcrack.endpoints.directory.responseModels import directory_model
from src.database.models import FcMasksSet
log = logging.getLogger(__name__)
ns = api.namespace('directory',
description='Endpoinsts for browsing filesystem of server.')
ALLOWED_EXTENSIONS = set(['txt'])
prefixlen = len(prefix)
@ns.route('')
class maskCollection(Resource):
@api.marshal_with(directory_model)
@api.expect(directory_parser)
def get(self):
"""
Returns list of files in directory.
"""
args = directory_parser.parse_args(request)
'''
import logging
from flask import request
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.graph.argumentsParser import job_graph_arguments
from src.api.fitcrack.endpoints.graph.functions import computeJobsGraph, computeHostGraph, \
computeHostPercentageGraph
from src.api.fitcrack.endpoints.batches.functions import getIdsFromBatch
from src.api.fitcrack.endpoints.graph.responseModels import job_graph_model, pie_graph_model
log = logging.getLogger(__name__)
ns = api.namespace('graph', description='Endpoints for graph presentation')
@ns.route('/jobsProgress')
class runningPackages(Resource):
@api.expect(job_graph_arguments)
@api.marshal_with(job_graph_model)
def get(self):
"""
Returns 2D graph representing progress of started jobs.
"""
args = job_graph_arguments.parse_args(request)
fromDate = args['from_date']
toDate = args['to_date']
* Licence: MIT, see LICENSE
'''
import logging
from flask import request
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.graph.argumentsParser import package_graph_arguments
from src.api.fitcrack.endpoints.graph.functions import computePackagesGraph, computeHostGraph, \
computeHostPercentageGraph
from src.api.fitcrack.endpoints.graph.responseModels import package_graph_model, pie_graph_model
log = logging.getLogger(__name__)
ns = api.namespace('graph',
description='Endpointy ktoré slúžia na vypisovanie grafov')
@ns.route('/packagesProgress')
class runningPackages(Resource):
@api.expect(package_graph_arguments)
@api.marshal_with(package_graph_model)
def get(self):
"""
Vracia 2D graf progresu spustených packagov.
"""
args = package_graph_arguments.parse_args(request)
fromDate = args['from_date']
toDate = args['to_date']
from flask_restplus import Resource, abort
from sqlalchemy import exc
from werkzeug.utils import secure_filename
from settings import HASHCAT_UTILS_PATH, EXE_OR_BIN, HCSTATS_DIR, DICTIONARY_DIR
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.markov.argumentsParser import makeMarkovFromDictionary_parser
from src.api.fitcrack.endpoints.markov.responseModels import hcStatsCollection_model
from src.api.fitcrack.functions import fileUpload, shellExec
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcHcstat, FcDictionary
log = logging.getLogger(__name__)
ns = api.namespace(
'markovChains',
description='Endpointy ktoré slúžia na pracu s HcStats subormi.')
ALLOWED_EXTENSIONS = set(['hcstat2'])
@ns.route('')
class markovCollection(Resource):
@api.marshal_with(hcStatsCollection_model)
def get(self):
"""
Vracia kolekciu HcStats suborov
"""
return {
'items': FcHcstat.query.filter(FcHcstat.deleted == False).all()
}
'''
* Author : see AUTHORS
* Licence: MIT, see LICENSE
'''
import logging
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.attacks.hashtypes import hashtypes
from src.api.fitcrack.endpoints.hashcat.functions import getTable
from src.api.fitcrack.endpoints.hashcat.responseModels import hashType_list, attackMode_list
log = logging.getLogger(__name__)
ns = api.namespace('hashcat', description='Endpoints for hashcat usage.')
@ns.route('/hashTypes')
class hashTypesCollection(Resource):
@api.marshal_with(hashType_list)
def get(self):
"""
Returns list of supported hashes.
"""
# hashtype = getTable("Hash modes")
return {'hashtypes': hashtypes}
import json
from flask import request
from flask_restplus import Resource
from flask_restplus import reqparse
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.jobTemplate.responseModels import templates_model, template_data
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcTemplate
log = logging.getLogger(__name__)
ns = api.namespace('template', description='Endpoints for job templates.')
add_model = api.schema_model('add_template', {'properties': {'template': {'type': 'string'}}})
#add_template_args = reqparse.RequestParser()
#add_template_args.add_argument('template', type=str, help='name of the template', required=True, location='json')
@ns.route('')
class template(Resource):
@api.expect(add_model)
@api.marshal_with(simpleResponse)
def put(self):
"""
Add or edit a job template.
"""
* Licence: MIT, see LICENSE
'''
import logging
from flask import request
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.host.argumentsParser import jobHost_parser
from src.api.fitcrack.endpoints.host.responseModels import page_of_hosts_model, boincHostDetail_model
from src.database import db
from src.database.models import Host, FcHostActivity, FcHostStatus
log = logging.getLogger(__name__)
ns = api.namespace('hosts', description='Operations with hosts.')
@ns.route('')
class hostsCollection(Resource):
@api.expect(jobHost_parser)
@api.marshal_with(page_of_hosts_model)
def get(self):
"""
Returns list of hosts.
"""
args = jobHost_parser.parse_args(request)
page = args.get('page', None)
per_page = args.get('per_page', None)
import logging
from flask import request
from flask_restplus import Resource, abort
from sqlalchemy import exc
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.settings.argumentsParser import settings_arguments
from src.api.fitcrack.endpoints.settings.responseModels import settings_model
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcSetting
log = logging.getLogger(__name__)
ns = api.namespace('settings', description='Endpoints for manipulating system settings.')
@ns.route('')
class settings(Resource):
@api.marshal_with(settings_model)
def get(self):
"""
Returns all system settings.
"""
settings = FcSetting.query.first() # single row table
return settings
@api.expect(settings_arguments)
@api.marshal_with(simpleResponse)
def post(self):
import logging
from flask import request
from flask_login import current_user, login_required
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.notifications.argumentsParser import notifications_parser
from src.api.fitcrack.endpoints.notifications.functions import getNotifications
from src.api.fitcrack.endpoints.notifications.responseModels import page_of_notifications_model, \
notification_count_model
from src.database.models import FcNotification
log = logging.getLogger(__name__)
ns = api.namespace('notifications',
description='Endpoints for graph representation.')
@ns.route('')
class notifications(Resource):
@api.expect(notifications_parser)
@api.marshal_with(page_of_notifications_model)
def get(self):
"""
Returns user's notifications.
"""
args = notifications_parser.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
markAsSeen = args.get('seen', True)
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.responseModels import simpleResponse
from src.api.fitcrack.endpoints.serverInfo.responseModels import serverinfo
from src.api.fitcrack.endpoints.serverInfo.functions import isComponentRunning
from src.api.fitcrack.endpoints.serverInfo.argumentsParser import operation
from src.api.fitcrack.functions import shellExec
from settings import PROJECT_DIR, PROJECT_USER, PROJECT_NAME, BOINC_SERVER_URI
import platform
from flask import request
from flask_restplus import abort
import xml.etree.ElementTree as ET
import urllib.request
log = logging.getLogger(__name__)
ns = api.namespace('serverInfo', description='Operácie so serverom')
@ns.route('/info')
class serverInfo(Resource):
@api.marshal_with(serverinfo)
def get(self):
"""
Informacie o serveri
"""
url = BOINC_SERVER_URI + '/' + PROJECT_NAME + '/server_status.php?xml=1'
request = urllib.request.Request(url)
try:
response = urllib.request.urlopen(request)
from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import DICTIONARY_DIR, HASHCAT_PATH, HASHCAT_DIR
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.dictionary.argumentsParser import dictionary_parser, dictionaryFromFile_parser
from src.api.fitcrack.endpoints.dictionary.functions import readingFromFolderPostProcces
from src.api.fitcrack.endpoints.dictionary.responseModels import dictionaries_model, dictData_model, \
dictionary_model
from src.api.fitcrack.functions import shellExec, fileUpload, allowed_file, getFilesFromFolder
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcDictionary
log = logging.getLogger(__name__)
ns = api.namespace('dictionary', description='Endpointy ktoré slúžia na pracu so slovnikmi')
ALLOWED_EXTENSIONS = set(['txt'])
@ns.route('')
class dictionaryCollection(Resource):
@api.marshal_with(dictionaries_model)
def get(self):
"""
Vracia kolekciu slovníkov
"""
dictionaries = getFilesFromFolder(DICTIONARY_DIR,FcDictionary, readingFromFolderPostProcces)
return {'items': dictionaries}
from src.api.fitcrack.endpoints.pcfg.argumentsParser import pcfg_parser, pcfgFromFile_parser, \
makePcfgFromDictionary_parser
from src.api.fitcrack.endpoints.pcfg.functions import readingFromFolderPostProcces, \
unzipGrammarToPcfgFolder, deleteUnzipedFolderDirectory, extractNameFromZipfile, \
createPcfgGrammarBin, calculateKeyspace, makePcfgFolder, moveGrammarToPcfgDir
from src.api.fitcrack.endpoints.pcfg.responseModels import pcfgs_model, pcfgData_model, \
pcfg_model, pcfgTree_model
from src.api.fitcrack.functions import shellExec, fileUpload, allowed_file, getFilesFromFolder, directory_tree
from src.api.fitcrack.responseModels import simpleResponse, file_content
from src.api.fitcrack.argumentsParser import path
from src.database import db
from src.database.models import FcPcfg, FcDictionary
log = logging.getLogger(__name__)
ns = api.namespace(
'pcfg', description='Endpoint for pcfg operations')
ALLOWED_EXTENSIONS = set(['zip'])
@ns.route('')
class pcfgCollection(Resource):
@api.marshal_with(pcfgs_model)
def get(self):
"""
Returns collection of pcfg
"""
return {'items': FcPcfg.query.filter(FcPcfg.deleted == False).all()}
from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import DICTIONARY_DIR, HASHCAT_PATH, HASHCAT_DIR
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.dictionary.argumentsParser import dictionary_parser, dictionaryFromFile_parser
from src.api.fitcrack.endpoints.dictionary.functions import readingFromFolderPostProcces
from src.api.fitcrack.endpoints.dictionary.responseModels import dictionaries_model, dictData_model, \
dictionary_model
from src.api.fitcrack.functions import shellExec, fileUpload, allowed_file, getFilesFromFolder, sorted_cp
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcDictionary
log = logging.getLogger(__name__)
ns = api.namespace('dictionary',
description='Endpoints for work with charset dictionary.')
ALLOWED_EXTENSIONS = set(['txt'])
@ns.route('')
class dictionaryCollection(Resource):
@api.marshal_with(dictionaries_model)
def get(self):
"""
Returns collection of dictionaries.
"""
#dictionaries = getFilesFromFolder(DICTIONARY_DIR, FcDictionary, readingFromFolderPostProcces)
dictionaries = FcDictionary.query.filter_by(deleted=False).all()
return {'items': dictionaries}
from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import MASKS_DIR, ROOT_DIR
from src.api.apiConfig import api
from src.api.fitcrack.attacks.functions import check_mask_syntax
from src.api.fitcrack.endpoints.markov.responseModels import hcStatsCollection_model
from src.api.fitcrack.endpoints.masks.argumentsParser import updateMask_parser
from src.api.fitcrack.endpoints.masks.responseModels import maskSet_model
from src.api.fitcrack.functions import fileUpload
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcMasksSet
log = logging.getLogger(__name__)
ns = api.namespace(
'masks', description='Endpointy ktoré slúžia na pracu s Masks subormi.')
ALLOWED_EXTENSIONS = set(['txt', 'hcmask'])
@ns.route('')
class maskCollection(Resource):
@api.marshal_with(hcStatsCollection_model)
def get(self):
"""
Vracia kolekciu HcStats suborov
"""
return {
'items':
FcMasksSet.query.filter(FcMasksSet.deleted == False).all()
}
from src.api.fitcrack.endpoints.serverInfo.responseModels import serverinfo, usageinfoList, usageinfo, dependency_report
from src.api.fitcrack.endpoints.serverInfo.functions import getCpuMemData
from src.api.fitcrack.endpoints.serverInfo.transfer import pack, unpack, dependency_check, ImportDependencyMissing
from src.api.fitcrack.endpoints.serverInfo.argumentsParser import operation, serverUsage_argument, export_options, dependency_list
from src.api.fitcrack.endpoints.graph.argumentsParser import job_graph_arguments
from src.database import db
from src.database.models import FcServerUsage
from settings import PROJECT_DIR, PROJECT_USER, PROJECT_NAME, BOINC_SERVER_URI
import platform
from flask import request, Response, stream_with_context
from flask_restplus import abort
import xml.etree.ElementTree as ET
import urllib.request
log = logging.getLogger(__name__)
ns = api.namespace('serverInfo', description='Operation with server.')
@ns.route('/info')
class serverInfo(Resource):
@api.marshal_with(serverinfo)
def get(self):
"""
Information about server.
"""
url = BOINC_SERVER_URI + '/' + PROJECT_NAME + '/server_status.php?xml=1'
request = urllib.request.Request(url)
try:
response = urllib.request.urlopen(request)
from flask import request, redirect, send_file
from flask_restplus import Resource, abort
from sqlalchemy import exc
from settings import RULE_DIR
from src.api.apiConfig import api
from src.api.fitcrack.argumentsParser import pagination
from src.api.fitcrack.endpoints.rule.argumentsParser import updateRule_parser, rule_parser
from src.api.fitcrack.endpoints.rule.responseModels import rules_model, rule_model, ruleData_model
from src.api.fitcrack.functions import fileUpload
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcRule
log = logging.getLogger(__name__)
ns = api.namespace('rule', description='Endpoints for work with rule files.')
ALLOWED_EXTENSIONS = set(['txt', 'rule'])
@ns.route('')
class ruleCollection(Resource):
@api.marshal_with(simpleResponse)
def post(self):
"""
Uploads rule file on server.
"""
# check if the post request has the file part
if 'file' not in request.files:
abort(500, 'No file part')
return redirect(request.url)
computeCrackingTime, visible_jobs_ids, editable_jobs_ids, actionable_jobs_ids, \
can_view_job, can_edit_job, can_operate_job
from src.api.fitcrack.endpoints.job.responseModels import page_of_jobs_model, page_of_jobs_model, \
verifyHash_model, crackingTime_model, newJob_model, job_big_model, verifyHashes_model, \
job_nano_list_model, job_user_permissions_model
from src.api.fitcrack.functions import shellExec
from src.api.fitcrack.attacks.functions import compute_prince_keyspace
from src.api.fitcrack.lang import status_to_code, job_status_text_to_code_dict, attack_modes
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcJob, Host, FcHost, FcWorkunit, FcHostActivity, FcMask, FcJobGraph, \
FcJobDictionary, FcPcfg, FcJobStatus, FcRule, FcUserPermission, FcUser, FcSetting
log = logging.getLogger(__name__)
ns = api.namespace('job', description='Operations with jobs.')
@ns.route('')
class jobsCollection(Resource):
@api.expect(jobList_parser)
@api.marshal_with(page_of_jobs_model)
def get(self):
"""
Returns list of jobs.
"""
args = jobList_parser.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
jobs_query = FcJob.query
* Licence: MIT, see LICENSE
'''
import logging
from flask import request
from flask_restplus import Resource
from src.api.apiConfig import api
from src.api.fitcrack.endpoints.host.argumentsParser import packageHost_parser
from src.api.fitcrack.endpoints.host.responseModels import page_of_hosts_model, boincHostDetail_model
from src.database import db
from src.database.models import Host, FcHostActivity, FcHostStatus
log = logging.getLogger(__name__)
ns = api.namespace('hosts', description='Operácie s hostami')
@ns.route('')
class hostsCollection(Resource):
@api.expect(packageHost_parser)
@api.marshal_with(page_of_hosts_model)
def get(self):
"""
Vracia list hostov
"""
args = packageHost_parser.parse_args(request)
from src.api.fitcrack.endpoints.package.argumentsParser import packageList_parser, packageJob_parser, \
packageOperation, verifyHash_argument, crackingTime_argument, addPackage_model, editHostMapping_argument, \
editPackage_argument
from src.api.fitcrack.endpoints.package.functions import delete_package, verifyHashFormat, create_package, \
computeCrackingTime
from src.api.fitcrack.endpoints.package.responseModels import page_of_packages_model, page_of_jobs_model, \
verifyHash_model, crackingTime_model, newPackage_model, package_model, verifyHashes_model
from src.api.fitcrack.functions import shellExec
from src.api.fitcrack.lang import statuses, package_status_text_to_code_dict
from src.api.fitcrack.responseModels import simpleResponse
from src.database import db
from src.database.models import FcJob, FcHost, FcWorkunit, FcHostActivity, FcMask, FcJobGraph, FcJobDictionary
log = logging.getLogger(__name__)
ns = api.namespace('jobs', description='Operácie s package')
@ns.route('')
class packagesCollection(Resource):
@api.expect(packageList_parser)
@api.marshal_with(page_of_packages_model)
def get(self):
"""
Vracia list balíčkov
"""
args = packageList_parser.parse_args(request)
page = args.get('page', 1)
per_page = args.get('per_page', 10)
