virtual void set_key_by_file(string key_file_name)
{
LOG(INFO) << "set key by key_file: " << key_file_name;
key_list.clear();
label_list.clear();
kl_info_vec.clear();
key_index_list.clear();
std::ifstream key_file(key_file_name);
string key;
int label;
//while (key_file >> key >>label)
string line;
while (std::getline(key_file, line))
{
vector<string> str_vec = string_split(line, ' ');
if (str_vec.size() < 2)
str_vec = string_split(line, '\t');
key = str_vec[0];
label = atoi(str_vec[1].c_str());
if (str_vec.size() >= 3)
{
if (key_pos_map_.find(key) != key_pos_map_.end())
{
LOG(INFO) << "ignore repeated key: " << key;
continue;
}
key_pos_map_[key] = atoll(str_vec[2].c_str());
if (str_vec.size() >= 4)
{
vector<float> tmp_info;
for (int info_idx = 3; info_idx < str_vec.size(); ++info_idx)
{
tmp_info.push_back(std::stof(str_vec[info_idx]));
}
kl_info_vec.push_back(tmp_info);
}
}
key_list.push_back(key);
label_list.push_back(label);
}
for (int i = 0; i < key_list.size(); ++i)
{
key_index_list.push_back(i);
}
if (key_pos_map_.size()>0)
{
is_key_pos_map_ready_ = true;
CHECK_EQ(key_pos_map_.size(), key_index_list.size())
<< "key_pos_map size vs key size: " << key_pos_map_.size() << " vs "
<< key_index_list.size();
LOG(INFO) << "key_pos_map size: " << key_pos_map_.size();
}
LOG(INFO) << "data size: " << key_index_list.size();
if (kl_info_vec.size()>0)
LOG(INFO) << "kl_info_size: " << kl_info_vec.size() << " dim: " << kl_info_vec[0].size();
}
void SshKeyController::refresh_key_files() {
QMutexLocker locker(&m_mutex); // Locks the mutex and unlocks when locker exits the scope
std::vector<SshKey> tmp;
QDir dir(CSettingsManager::Instance().ssh_keys_storage());
if (!dir.exists()) {
qCritical(
"Wrong ssh keys storage : %s",
dir.absolutePath().toStdString().c_str());
return;
}
QStringList name_filters({"*.pub"});
QStringList tmp_list =
dir.entryList(name_filters, QDir::Files | QDir::NoSymLinks);
for (auto i = tmp_list.begin(); i != tmp_list.end(); ++i) {
QString file_path = dir.path() + QDir::separator() + *i;
QFile key_file(file_path);
if (!key_file.open(QFile::ReadOnly)) {
qCritical(
"Can't open ssh-key file : %s, reason : %s",
file_path.toStdString().c_str(),
key_file.errorString().toStdString().c_str());
continue;
}
QFileInfo fi(key_file);
if (!fi.baseName().contains(QRegularExpression("[/|\\\\$%~\"*?:<>^]"))
&& !(fi.baseName()[0] == '.')) {
SshKey key;
QByteArray arr_content = key_file.readAll();
arr_content.truncate(arr_content.size() - 1); // hack for hub
key.file_name = *i;
key.content = QString(arr_content).remove(QRegExp("[\\n\\t\\r\\v\\f]"));
key.path = dir.absolutePath() + QDir::separator() + (*i);
tmp.push_back(key);
std::vector<SshKey>::iterator it;
it = std::find_if(m_keys.begin(), m_keys.end(),
find_content(key.content));
if (it == m_keys.end()) {
m_keys.push_back(key);
}
}
key_file.close();
}
emit finished_check_environment_keys();
}
/**
* Точка входа в программу.
*
* Функция создает объект приложения qt,
* настраивает кодировку, задает имя программы и организации,
* создает главное окно и запускает цикл обработки событий app.exec().
*/
int main(int argc, char ** argv)
{
QTextCodec *codec = QTextCodec::codecForName("Windows-1251");
QTextCodec::setCodecForCStrings(codec);
QCoreApplication::setOrganizationName("ANT");
QCoreApplication::setApplicationName("R245 monitor");
QApplication app( argc, argv );
if(!QFile::exists("lib/libr245.dll"))
{
utils.showMessage(QMessageBox::Warning, "Ошибка", "В папке lib не найдена библиотека libr245.dll"); }
else if(!QFile::exists("lib/ftd2xx.dll"))
{
utils.showMessage(QMessageBox::Warning, "Ошибка", "В папке lib не найдена библиотека ftd2xx.dll"); }
else if(utils.loadLibrary("lib/libr245.dll"))
{
QStringList * str_list = new QStringList();
utils.setDevList(str_list);
if(!QFile::exists("key.txt"))
{
utils.showMessage(QMessageBox::Warning, "Ошибка", "В папке с программой не найден файл с ключом key.txt");
} else {
QFile key_file("key.txt");
utils.openFile(&key_file, QIODevice::ReadOnly);
QTextStream kstr(&key_file);
while(!kstr.atEnd())
{
*str_list << kstr.readLine();
}
qDebug() << "KEY count = " << str_list->size();
utils.closeFile(&key_file);
}
//====================================================================
MainWindow win;
win.show();
return app.exec();
} else
{
utils.showMessage(QMessageBox::Warning, "Ошибка", "Не удается загрузить библиотеку libr245.dll");
return 1;
}
return 0;
}
bool KeyShare::Contains(const QString &name) const
{
if(_keys.contains(name)) {
return true;
} else if(_fs_enabled) {
QString key_path = _path + "/" + name + ".pub";
QFile key_file(key_path);
return key_file.exists();
}
return false;
}
main(int argc, char *argv[]){
/** Check the number of parameters */
if (argc < 6) {
/** Tell the user how to run the program */
cerr << "Usage: " << argv[0] << " key_file rows encrows noise num_threads" << endl;
return 1;
}
/** Set the random seed for noise parameter generation */
srand(time(NULL));
mr_init_threading();
PFC pfc(AES_SECURITY);
SecureSelect *db=NULL;
int m=0;
string key_file(argv[1]);
string table_name(argv[2]);
string enctable_name(argv[3]);
int rand_lim = atoi(argv[4]);
int num_threads = atoi(argv[5]);
db = new SecureSelect(&pfc,pfc.order());
if(!db->LoadKey(key_file))
return 0;
if(rand_lim<1){
cout << "Random paramter < 1, it has to be >= 1" << endl;
return 0;
}
#ifdef VERBOSE
int start = getMilliCount();
#endif
db->EncryptRowsMT(table_name,enctable_name,rand_lim, num_threads);
// db->EncryptRows(table_name,enctable_name,rand_lim);
#ifdef VERBOSE
int milliSecondsElapsed = getMilliSpan(start);
cout << "\texec time " << milliSecondsElapsed << endl;
#endif
}
void KeyShare::CheckPath()
{
QDir key_path(_path, "*.pub");
foreach(const QString &key_name, key_path.entryList()) {
QString path = _path + "/" + key_name;
QFile key_file(path);
key_file.open(QIODevice::ReadOnly);
QSharedPointer<QSslCertificate> cert(new QSslCertificate(&key_file, QSsl::Der));
QSslKey pubkey = cert->publicKey();
QSharedPointer<AsymmetricKey> key(new DsaPublicKey(pubkey.toDer()));
if(!key->IsValid()) {
qDebug() << "Invalid key:" << path;
continue;
}
QString name = key_name.left(key_name.length() - 4);
AddCertificate(name, cert);
}
}
SslServer::SslServer(QObject *parent) : QObject(parent)
{
qRegisterMetaType<PeerData>("PeerData");
m_max_connections = 0;
m_server = nullptr;
QByteArray password;
if (!QFileInfo("../data/cert.pem").exists() || !QFileInfo("../data/key.pem").exists())
{
QByteArray confirm_password;
password = getPassword("Enter password to encrypt private key:");
confirm_password = getPassword("Repeat password to encrypt private key:");
printf("\n");
fflush(stdout);
if (password != confirm_password)
{
password.fill(char(0));
confirm_password.fill(char(0));
DEBUG_FUNCTION("Different passwords!");
return;
}
confirm_password.fill(char(0));
DEBUG_FUNCTION("Generating certificate...");
Certificate certificate_genarator;
bool success = certificate_genarator.generate("US", "Server", "127.0.0.1", password);
if (!success)
{
DEBUG_FUNCTION("Keys not generated!" << "Error(s):" << qPrintable(QString("\n%0").arg(certificate_genarator.errorString())));
return;
}
DEBUG_FUNCTION("Keys generated!");
}
QFile key_file("../data/key.pem");
if (!key_file.open(QFile::ReadOnly))
{
DEBUG_FUNCTION("Private key file could not be openned!");
return;
}
QFile cert_file("../data/cert.pem");
if (!cert_file.open(QFile::ReadOnly))
{
DEBUG_FUNCTION("Public key file could not be openned!");
return;
}
if (password.isNull())
password = getPassword("Enter password to decrypt private key:");
printf("\n");
fflush(stdout);
m_key = QSslKey(&key_file, QSsl::Rsa, QSsl::Pem, QSsl::PrivateKey, password);
password.fill(char(0));
if (m_key.isNull())
{
DEBUG_FUNCTION("Private key is null!");
return;
}
m_cert = QSslCertificate(&cert_file, QSsl::Pem);
if (m_cert.isNull())
{
DEBUG_FUNCTION("Public key is null!");
return;
}
QByteArray hash = m_cert.digest(QCryptographicHash::Sha256).toHex().toUpper();
QByteArray formatted_hash;
for (int i = hash.size() - 2; i >= 0; i -= 2)
{
formatted_hash.prepend(hash.mid(i, 2));
formatted_hash.prepend(":");
}
formatted_hash.remove(0, 1);
DEBUG_FUNCTION("Certificate fingerprint:" << qPrintable(formatted_hash));
key_file.close();
cert_file.close();
DEBUG_FUNCTION("Openning database...");
if (!m_sql.open())
{
DEBUG_FUNCTION("Could not open database!");
return;
}
DEBUG_FUNCTION("Database openned!");
listen();
}
bool validate_enc_signature( const wxString &sig_file_name, const wxString &key_file_name)
{
bool ret_val = false;
// Read the key_file_name, and create an instance of pub_key
pub_key public_key;
if( wxFileName::FileExists(key_file_name) ){
wxTextFile key_file( key_file_name );
if( key_file.Open() ){
wxArrayString key_array;
wxString line = key_file.GetFirstLine();
while( !key_file.Eof() ){
key_array.Add(line);
line = key_file.GetNextLine();
}
public_key.ReadKey( key_array );
}
}
if( !public_key.m_OK )
return false;
// Validate the ENC signature file according to Spec 5.4.2.7 and 10.6.2
// Read the file into a string array
if( wxFileName::FileExists(sig_file_name) ){
wxTextFile sig_file( sig_file_name );
if( sig_file.Open() ){
wxArrayString sig_array;
wxString line = sig_file.GetFirstLine();
while( !sig_file.Eof() ){
sig_array.Add(line);
line = sig_file.GetNextLine();
}
// Remove the first two (R/S) lines, the Data Server Signature
for(unsigned int i=0 ; i < sig_array.Count() ; i++){
wxString line = sig_array[i];
if( line.Upper().Find(_T("PART R")) != wxNOT_FOUND ){
sig_array.RemoveAt(i, 2);
break;
}
}
for(unsigned int i=0 ; i < sig_array.Count() ; i++){
wxString line = sig_array[i];
if( line.Upper().Find(_T("PART S")) != wxNOT_FOUND ){
sig_array.RemoveAt(i, 2);
break;
}
}
// Remove and save the next two R/S signature lines
wxArrayString sig_save_array;
for(unsigned int i=0 ; i < sig_array.Count() ; i++){
wxString line = sig_array[i];
if( line.Upper().Find(_T("PART R")) != wxNOT_FOUND ){
sig_save_array.Add(line);
sig_save_array.Add(sig_array[i+1]);
sig_array.RemoveAt(i, 2);
break;
}
}
for(unsigned int i=0 ; i < sig_array.Count() ; i++){
wxString line = sig_array[i];
if( line.Upper().Find(_T("PART S")) != wxNOT_FOUND ){
sig_save_array.Add(line);
sig_save_array.Add(sig_array[i+1]);
sig_array.RemoveAt(i, 2);
break;
}
}
// Make one long string of the remainder of the file, to treat as a blob
wxString pub_key_blob;
for(unsigned int i=0 ; i < sig_array.Count() ; i++){
wxString line = sig_array[i];
pub_key_blob += line;
pub_key_blob += _T("\r\n");
}
wxCharBuffer blob_buf = pub_key_blob.ToUTF8();
// Hash the blob
SHA1Context sha1;
uint8_t sha1sum[SHA1HashSize];
SHA1Reset(&sha1);
SHA1Input(&sha1, (uint8_t *)blob_buf.data(), strlen( blob_buf.data()) );
SHA1Result(&sha1, sha1sum);
mp_int hash, r, s;
mp_init(&hash);
mp_init( &r );
mp_init( &s );
mp_read_unsigned_bin(&hash, sha1sum, sizeof(sha1sum));
// Prepare the signature
for(unsigned int i=0 ; i < sig_save_array.Count() ; i++){
wxString line = sig_save_array[i];
if( line.Upper().Find(_T("PART R")) != wxNOT_FOUND ){
if( (i+1) < sig_save_array.Count() ){
wxString sig_line = sig_save_array[i+1];
sig_line.Replace(_T(" "), _T("") );
wxCharBuffer lbuf = sig_line.ToUTF8();
mp_read_radix(&r, lbuf.data(), 16);
}
}
else if( line.Upper().Find(_T("PART S")) != wxNOT_FOUND ){
if( (i+1) < sig_save_array.Count() ){
wxString sig_line = sig_save_array[i+1];
sig_line.Replace(_T(" "), _T("") );
wxCharBuffer lbuf = sig_line.ToUTF8();
mp_read_radix(&s, lbuf.data(), 16);
}
}
}
// Verify the blob
int val = _dsa_verify_hash(&r, &s, &hash, &(public_key.m_g), &(public_key.m_p), &(public_key.m_q), &(public_key.m_y) );
ret_val = (val == 1);
}
}
return ret_val;
}
int main(int argc, char **argv)
{
QCoreApplication qca(argc, argv);
QStringList args = QCoreApplication::arguments();
Settings settings = Settings::CommandLineParse(args);
if(settings.Help || !settings.IsValid()) {
QTextStream qtout(stdout, QIODevice::WriteOnly);
qtout << "usage: " << args[0] << " [options] [settings.conf]\n\n";
qtout << "options:\n";
qtout << Settings::GetUsage() << "\n";
if(!settings.Help) {
qtout << "error: " << settings.GetError() << "\n\n";
}
return -1;
}
Settings::ApplicationSettings = settings;
QList<QSharedPointer<Node> > nodes;
QSharedPointer<ISink> default_sink(new DummySink());
QSharedPointer<SinkMultiplexer> app_sink(new SinkMultiplexer());
QSharedPointer<CommandLine> commandline;
QSharedPointer<SignalSink> signal_sink(new SignalSink());
app_sink->AddSink(signal_sink.data());
QSharedPointer<KeyShare> keys(new KeyShare(settings.PublicKeys));
Hash hashalgo;
foreach(const Id &server, settings.ServerIds) {
QString serv = server.ToString();
if(!keys->Contains(serv)) {
qFatal("Missing key for %s", serv.toLatin1().data());
}
Q_ASSERT(Id(hashalgo.ComputeHash(keys->GetKey(serv)->GetByteArray())) == server);
}
QList<Address> local_end_points = settings.LocalEndPoints;
for(int idx = 0; idx < settings.LocalNodeCount; idx++) {
Id local_id = idx < settings.LocalId.count() ? settings.LocalId[idx] : Id();
QSharedPointer<AsymmetricKey> key;
QString key_path = settings.PrivateKeys + "/" + local_id.ToString();
QFile key_file(key_path);
if(key_file.exists()) {
key = QSharedPointer<AsymmetricKey>(new DsaPrivateKey(key_path));
} else {
QByteArray id = local_id.GetByteArray();
key = QSharedPointer<AsymmetricKey>(new DsaPrivateKey(id, true));
}
QSharedPointer<ISink> nsink = (idx == 0) ? app_sink.dynamicCast<ISink>() : default_sink;
QSharedPointer<Overlay> overlay(new Overlay(local_id, local_end_points,
settings.RemoteEndPoints, settings.ServerIds));
overlay->SetSharedPointer(overlay);
CreateRound create_round = RoundFactory::GetCreateRound(settings.RoundType);
QSharedPointer<Session> session;
if(settings.ServerIds.contains(local_id)) {
session = MakeSession<ServerSession>(overlay, key, keys, create_round);
} else {
session = MakeSession<ClientSession>(overlay, key, keys, create_round);
}
session->SetSink(nsink.data());
QSharedPointer<Node> node(new Node(key, keys, overlay, nsink, session));
nodes.append(node);
for(int idx = 0; idx < local_end_points.count(); idx++) {
local_end_points[idx] = AddressFactory::GetInstance().
CreateAny(local_end_points[idx].GetType());
}
}
QScopedPointer<WebServer> ws;
// QScopedPointer<SessionEntryTunnel> tun_entry;
// QScopedPointer<SessionExitTunnel> tun_exit;
if(settings.Console) {
commandline = QSharedPointer<CommandLine>(new CommandLine(nodes));
QObject::connect(&qca, SIGNAL(aboutToQuit()), commandline.data(), SLOT(Stop()));
commandline->Start();
app_sink->AddSink(commandline.data());
}
if(settings.WebServer) {
ws.reset(new WebServer(settings.WebServerUrl));
/* Stop Web server when application is about to quit */
QObject::connect(&qca, SIGNAL(aboutToQuit()), ws.data(), SLOT(Stop()));
/* When the web server stops, quit the application */
QObject::connect(ws.data(), SIGNAL(Stopped()), &qca, SLOT(quit()));
QSharedPointer<GetMessagesService> get_messages(new GetMessagesService());
QObject::connect(signal_sink.data(), SIGNAL(IncomingData(const QByteArray&)),
get_messages.data(), SLOT(HandleIncomingMessage(const QByteArray&)));
ws->AddRoute(QHttpRequest::HTTP_GET, "/session/messages", get_messages);
QSharedPointer<GetFileService> get_webpage(new GetFileService("index.html"));
ws->AddRoute(QHttpRequest::HTTP_GET, "/web", get_webpage);
QSharedPointer<GetDirectoryService> get_dir(new GetDirectoryService("webpath"));
ws->AddRoute(QHttpRequest::HTTP_GET, "/dir", get_dir);
QSharedPointer<SessionService> session_serv(new SessionService(nodes[0]->GetSession()));
ws->AddRoute(QHttpRequest::HTTP_GET, "/session", session_serv);
QSharedPointer<SendMessageService> send_message(new SendMessageService(nodes[0]->GetSession()));
ws->AddRoute(QHttpRequest::HTTP_POST, "/session/send", send_message);
// QSharedPointer<BuddiesService> bs(new BuddiesService(nodes[0]->GetSessionManager()));
// ws->AddRoute(QHttpRequest::HTTP_GET, "/session/buddies", bs);
ws->Start();
}
