void Database::init()
{
std::map<string, string> insertParamMap0 = { {"id", "1"},
{"username", "admin"},
{"password", encryptPassword("admin")} };
std::map<string, string> insertParamMap1 = { {"id", "2"},
{"username", "anonymous"},
{"password", encryptPassword("anonymous")} };
std::map<string, string> insertParamMap2 = { {"id", "3"},
{"username", "charles"},
{"password", encryptPassword("charles")} };
std::map<string, string> insertParamMap3 = { {"id", "4"},
{"username", "davey"},
{"password", encryptPassword("davey")} };
std::map<string, string> selectParamMap = { {"id", "1"}, {"username", "Paul"} };
std::map<string, string> updateParamMap = { {"username", "davey"}, {"password", "dddd"} };
create();
insert("user", insertParamMap0);
insert("user", insertParamMap1);
insert("user", insertParamMap2);
insert("user", insertParamMap3);
//select("user", selectParamMap);
// init user's root working directory
if(findALL("user"))
{
vector< map<string ,string> > myresultMapVector;
getResult(myresultMapVector);
for (vector< map<string ,string> >::iterator iter=myresultMapVector.begin(); iter!=myresultMapVector.end(); ++iter)
{
string dirString(ROOTDIR);
dirString += (*iter)["USERNAME"];
DIR* d = opendir(dirString.c_str());
if(d)
{
fprintf(stderr, "Already exists: %s\n", dirString.c_str());
closedir(d);
}else if(mkdir(dirString.c_str(), 0777) == -1)
{
char buf[MAXLINE];
fprintf(stdout, "Error(%s): %s\n", dirString.c_str(), strerror_r(errno, buf, MAXLINE));
} else {
fprintf(stdout, "Directory created: %s\n", dirString.c_str());
}
//traverseFiles(dirString);
}
}
//update("user", "2", updateParamMap);
//find("user", "2");
}
/*!
*
* @param username
* @param password
* @return
*/
QMap<QString, Customer>* Database::loginAsAdmin(QString username, QString password){
unsigned* digest = encryptPassword(password);
QMap<QString, Customer>* customerMap = new QMap<QString, Customer>();
if(validateAdminLogin(username, digest)){
sqlite3_stmt* stmt;
int rc = sqlite3_prepare_v2(connection, "SELECT c_name FROM ics_customers", -1, &stmt, NULL);
rc = sqlite3_step(stmt);
while(rc != SQLITE_DONE){
QString name = QString(static_cast<const char*>(sqlite3_column_blob(stmt, 0)));
customerMap->insert(name, Customer(connection, name));
rc = sqlite3_step(stmt);
}
}
else{
ostringstream ex;
ex << "Invalid login by " << username.toStdString();
throw new InvalidLoginException(ex.str().c_str());
}
return customerMap;
}
/**
* Encrypt a password for storing in the MaxScale.cnf file
*
* @param argc Argument count
* @param argv Argument vector
*/
int
main(int argc, char **argv)
{
char *enc, *pw;
if (argc != 2)
{
fprintf(stderr, "Usage: %s <password>\n", argv[0]);
exit(1);
}
pw = calloc(81,sizeof(char));
if(pw == NULL){
fprintf(stderr, "Error: cannot allocate enough memory.");
exit(1);
}
strncpy(pw,argv[1],80);
if ((enc = encryptPassword(pw)) != NULL){
printf("%s\n", enc);
}else{
fprintf(stderr, "Failed to encode the password\n");
}
free(pw);
return 0;
}
/*!
*
* @param username
* @param password
* @param customer
*/
void Database::registerCustomer(QString username, QString password, QString customer){
unsigned* digest = encryptPassword(password);
if(checkKeyCollision("ics_customer_logins", "cl_username", username.toStdString()) ||
checkKeyCollision("ics_customer_logins", "cl_customer", customer.toStdString())){
throw new KeyCollisionException("Username already exists or customer already has an account.");
}
ostringstream sqlCmmd;
sqlCmmd << "INSERT INTO ics_customer_logins (cl_customer, cl_password_part_one, "
<< "cl_password_part_two, cl_password_part_three, cl_password_part_four, "
<< "cl_password_part_five, cl_username) VALUES ('"
<< customer.toStdString() << "', "
<< digest[0] << ", "
<< digest[1] << ", "
<< digest[2] << ", "
<< digest[3] << ", "
<< digest[4] << ", '"
<< username.toStdString() << "')";
char* errMsg;
sqlite3_exec(connection, sqlCmmd.str().c_str(), NULL, 0, &errMsg);
if(errMsg != NULL){
cerr << errMsg << endl;
}
}
/**
* Encrypt a password for storing in the MaxScale.cnf file
*
* @param argc Argument count
* @param argv Argument vector
*/
int
main(int argc, char **argv)
{
char *enc, *pw;
int arg_count = 6;
char *home;
char** arg_vector;
int rval = 0;
if (argc != 3)
{
fprintf(stderr, "Usage: %s <file> <password>\n", argv[0]);
return 1;
}
arg_vector = malloc(sizeof(char*)*(arg_count + 1));
if(arg_vector == NULL)
{
fprintf(stderr,"Error: Memory allocation failed.\n");
return 1;
}
arg_vector[0] = strdup("logmanager");
arg_vector[1] = strdup("-j");
arg_vector[2] = strdup("/var/log/maxscale");
arg_vector[3] = "-o";
arg_vector[4] = "-l";
arg_vector[5] = "LOGFILE_ERROR";
arg_vector[6] = NULL;
skygw_logmanager_init(arg_count,arg_vector);
free(arg_vector[2]);
free(arg_vector);
pw = calloc(81,sizeof(char));
if(pw == NULL){
fprintf(stderr, "Error: cannot allocate enough memory.");
return 1;
}
strncpy(pw,argv[2],80);
if ((enc = encryptPassword(argv[1],pw)) != NULL){
printf("%s\n", enc);
}else{
fprintf(stderr, "Failed to encode the password\n");
rval = 1;
}
free(pw);
skygw_log_sync_all();
skygw_logmanager_done();
return rval;
}
bool GJContext::SignIn(LPCTSTR username,LPCTSTR password,CLoginFrame *loginFrame)
{
StopRecv();
this->m_pLoginFrame=loginFrame;
bool bOk=true;
JID *nSelf=new JID();
if(!nSelf)
{
bOk=false;
}else if(!nSelf->setServer(m_Server)||!nSelf->setUsername(utf8enc(username)))
{
bOk=false;
}else {
if(m_pClient)
m_pClient->disconnect();
m_pClient=new Client(*nSelf,encryptPassword(utf8enc(password)),m_Port);
m_pVCardMgr=new VCardManager(m_pClient);
if(!m_pClient)
bOk=false;
else
{
m_pClient->registerConnectionListener(this);
m_pClient->registerIqHandler(this,0);
m_pClient->registerMessageHandler(this);
m_pClient->rosterManager()->registerRosterListener(this,false);
bOk= m_pClient->connect(false);
}
}
if(!bOk&&nSelf)
delete nSelf;
else
{
if(m_pSelf)
delete m_pSelf;
m_pSelf=nSelf;
StartRecv();
}
return bOk;
}
/*!
*
* @param username
* @param password
* @return
*/
Customer* Database::loginAsCustomer(QString username, QString password){
unsigned* digest = encryptPassword(password);
Customer* customer;
if(validateCustomerLogin(username, digest)){
ostringstream sqlCmmd;
sqlCmmd << "SELECT cl_customer FROM ics_customer_logins WHERE cl_username = '******'";
sqlite3_stmt* stmt;
sqlite3_prepare_v2(connection, sqlCmmd.str().c_str(), -1, &stmt, NULL);
sqlite3_step(stmt);
customer = new Customer(connection, QString(static_cast<const char*>(sqlite3_column_blob(stmt, 0))));
}
else{
ostringstream ex;
ex << "Invalid login by " << username.toStdString();
throw new InvalidLoginException(ex.str().c_str());
}
return customer;
}
/*!
*
* @param username
* @param password
*/
void Database::registerAdmin(QString username, QString password){
unsigned* digest = encryptPassword(password);
if(checkKeyCollision("ics_admin_logins", "al_admin", username.toStdString())){
throw new KeyCollisionException("Admin username already exists.");
}
ostringstream sqlCmmd;
sqlCmmd << "INSERT INTO ics_admin_logins (al_admin, al_password_part_one, "
<< "al_password_part_two, al_password_part_three, al_password_part_four, "
<< "al_password_part_five) VALUES ('"
<< username.toStdString() << "', "
<< digest[0] << ", "
<< digest[1] << ", "
<< digest[2] << ", "
<< digest[3] << ", "
<< digest[4] << ")";
char* errMsg;
sqlite3_exec(connection, sqlCmmd.str().c_str(), NULL, 0, &errMsg);
if(errMsg != NULL){
cerr << errMsg << endl;
}
}
void LLSavedLoginEntry::setPassword(const std::string& value)
{
mEntry.insert("password", encryptPassword(value));
}
void bluetoothProcessReply(SoftwareSerial* bluetoothSerial, char *inputString)
{
char encryptedPassword[2 * PASSWORD_SIZE]; //make them more local
char shortEncryptedPassword[PASSWORD_SIZE];
char password[PASSWORD_SIZE];
char message[MESSAGE_SIZE];
memset(encryptedPassword, 0, 2 * PASSWORD_SIZE);
memset(shortEncryptedPassword, 0, PASSWORD_SIZE);
memset(password, 0, PASSWORD_SIZE);
memset(message, 0, MESSAGE_SIZE);
int typeCommand = getTypeCommand(inputString);
switch (typeCommand)
{
case '0' + 1:
{ // add new entry
getLastMessage(inputString, password);
if (encryptPassword((const unsigned char*)password, (const unsigned char*)key, PASSWORD_CHUNCKS, (unsigned char*)encryptedPassword)) {
generateBluetoothAddMessage(inputString, encryptedPassword, strlen(password), message);
setMessageReceiver(Phone);
storeInDataBuffer(message);
memset(message, '\0', MESSAGE_SIZE);
generateStoredInBuffer(message);
sendToBluetooth(bluetoothSerial, message);
}
else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
case '0' + 2: //retrive password
case '0' + 13: //retrive note
{
getLastMessage(inputString, encryptedPassword);
generateShortPassword(encryptedPassword, shortEncryptedPassword);
byte l = getPasswordLength(inputString);
if (decryptPassword((unsigned char*)shortEncryptedPassword, (unsigned char*)key, PASSWORD_CHUNCKS, l, (unsigned char*)password)) {
generateSerialRetriveInfo(password, message);
setMessageReceiver(Pc);
storeInDataBuffer(message);
}
else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
case '0' + 5:
{ // get from message and store the hash value and close connection
char hash[HASH_SIZE]; //input = "5:hash_value\n
memset(hash, '\0', HASH_SIZE);
getLastMessage(inputString, hash);
writeHash(hash);
}
break;
case '0' + 6:
{ //read hash from EERPOM and send back to bluetooth
char hash[HASH_SIZE]; //input = 6:\n
memset(hash, '\0', HASH_SIZE);
readHash(hash);
generateBluetoothRetrieveHash(hash, HASH_SIZE, message); //message = 6:hash_value\n
storeInDataBuffer(message);
setMessageReceiver(Phone);
setEnableBluetoothOperations(true);
}
break;
case '0' + 4:
{
char lastTimeUsed[LAST_TIME_USED_SIZE];
memset(lastTimeUsed, '\0', LAST_TIME_USED_SIZE);
readLastTimeUsed(lastTimeUsed);
generateBluetoothLastTimeUsed(lastTimeUsed, LAST_TIME_USED_SIZE, message);
//Serial.print(message);
sendToBluetooth(bluetoothSerial, message);
}
break;
case '0' + 10:
{
char lastTimeUsed[LAST_TIME_USED_SIZE];
memset(lastTimeUsed, '\0', LAST_TIME_USED_SIZE);
getLastMessage(inputString, lastTimeUsed);
writeLastTimeUsed(lastTimeUsed);
}
break;
case '0' + 7:
{ // generate password
if ((generatePassword(inputString, password, PASSWORD_CHUNCKS)) &&
(encryptPassword((const unsigned char*)password, (const unsigned char*)key, PASSWORD_CHUNCKS, (unsigned char*)encryptedPassword))) {
generateBluetoothAddMessage(inputString, encryptedPassword, strlen(password), message);
setMessageReceiver(Phone);
storeInDataBuffer(message);
memset(message, '\0', MESSAGE_SIZE);
generateStoredInBuffer(message);
sendToBluetooth(bluetoothSerial, message);
} else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
case '0' + 8:
{ // get the salt
char salt[SALT_SIZE];
memset(salt, '\0', SALT_SIZE);
getLastMessage(inputString, salt);
readKey(key, KEY_SIZE, salt);
}
break;
case '0' + 9:
{ // is alive message
generateIsAliveMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
break;
case '0' + 12:
{ //add note
getLastMessage(inputString, password);//password = note text
if (encryptPassword((const unsigned char*)password, (const unsigned char*)key, PASSWORD_CHUNCKS, (unsigned char*)encryptedPassword)) {
generateBluetoothAddNote(inputString, encryptedPassword, strlen(password), message);
setMessageReceiver(Phone);
storeInDataBuffer(message);
generateStoredInBuffer(message);
sendToBluetooth(bluetoothSerial, message);
}
else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
default:
{
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
break;
}
}
int main()
{
std::string encrypt = encryptPassword("password");
return 0;
}
