OwnCloud Modifikationen

You are viewing an old revision of this post, from December 29, 2014 @ 16:41:36. See below for differences between this version and the current revision.

//Compile Command:
//rm -frv mysql_user_check; clear; g++ -g -Wall -o mysql_user_check mysql_user_check.cpp -L/usr/lib64/mysql -lmysqlclient; ./mysql_user_check;
//rm -frv mysql_user_check;clear; g++ -g -c -O2 -Wall -o sha1.o sha1.c ;g++ -g -c -O2 -Wall -o mysql_user_check.o mysql_user_check.cpp; g++ -Wall -g -o mysql_user_check mysql_user_check.o sha1.o -L/usr/lib64/mysql -lmysqlclient;  ./mysql_user_check;
//TO DO:
//Wenn nur ein Parameter übergeben wird abbruch verhindern.
#include <mysql/mysql.h>
#include <stdio.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <vector>
#include <iomanip>
#include <cstdio>
#include <sstream>
#include “sha1.h”

using namespace std;

int main(int argc, char *argv[])
{
//Via ARGV, Passwort aus PHP nach CPP übergeben.

MYSQL *mysql_handle;
MYSQL_RES *result;
MYSQL_ROW row;
char *query;
int mysql_status_code;
int reihen_nummer;
int zellen_nummer;

mysql_handle = mysql_init(NULL);

//cout<<“Mysql Handle: “<<mysql_handle<<endl;

//mysql_real_connect(mysql_handle,”127.0.0.1″,”root”,”Passwort!”,”test_datenbank”,0,NULL,0);
mysql_real_connect(mysql_handle,”127.0.0.1″,”root”,”Passwort!”,”owncloud”,0,NULL,0);

//query=”SELECT * FROM `owncloud`.`oc_users`;”;
//query=”INSERT INTO `owncloud`.`oc_users` (`uid`, `password`) VALUES (‘USER’, ’60c6d277a8bd81de7fdde19201bf9c58a3df08f4′);”;
//query=”SELECT * FROM `owncloud`.`oc_users` WHERE uid=’test2′;”;
//cout<<“User: “<<argv[1]<<“\n”;

string user;
user=argv[1];
string password;
password=argv[2];
//cout<<“USER: “<<user<<“\n”;
//cout<<“Passowrd: “<<password<<“\n”;
string query_string;
query_string = “SELECT * FROM `owncloud`.`oc_users` WHERE uid='” + user + “‘;”;
//query_string = “INSERT INTO `owncloud`.`oc_users` (`uid`, `password`) VALUES (‘” + user + “‘, ‘” + password + “‘);”;
query = (char *) query_string.c_str();

//cout<<“SQL Query: “<<query<<endl;

mysql_status_code=mysql_real_query(mysql_handle,query,(unsigned int) strlen(query));
//cout<<“mysql status code: “<<mysql_status_code<<endl;

if (mysql_status_code > 0)
{
//cout<<“Fehler mit dem SQL Server: “<<mysql_error(mysql_handle)<<endl;;
}
else
{
//cout<<“Query erfolgreich !!”<<endl;
}

result=mysql_use_result(mysql_handle);
//cout<<“MYsql Result: “<<result<<endl;

//cout<<“Filed count: “<<mysql_field_count<<endl<<endl;

for(reihen_nummer=0;reihen_nummer<=mysql_field_count(mysql_handle);reihen_nummer++)
{
row=mysql_fetch_row(result);

cout<<“row: “<<row<<endl;
/*
if(row==0)
{
cout<<“Ende des Datenbank Inhalts !!”<<endl;
break;
}
*/
/*
for(zellen_nummer=0; zellen_nummer < mysql_num_fields(result); zellen_nummer++)
{
cout<<“Zelleninhalt: “<<row[zellen_nummer]<<endl;
//Check ob User Bereits in Datenbank, wenn ja nichts machen wenn nicht eintragen
}

cout<<endl;
*/
if (row > 0)
{
cout<<“Gefunden\n”;
//Wenn gefunden nichts machen
exit(0);
}
else
{
cout<<“NICHT Gefunden\n”;
//Wenn nicht gefunden user anlegen. SHA1 Engine anbinden.
//################################################################################################
SHA1Context sha; //SHA1 wird initialisiert

//char text[] = {“Alexander”}; //Klartext String der berechnet werden soll
char *text = {(char *) password.c_str()}; //Klartext String der berechnet werden soll

//cout<<“SHA1 Klartext: “<<text<<endl;

int status = 0;

//cout<<“Textlaenge: “<<strlen(text)<<endl;

status = SHA1Reset(&sha);

//cout<<“SHA1Reset: “<<status<<endl;

status = SHA1Input(&sha,(const unsigned char *) text, strlen(text)); //Klartext Daten werden berechnet

//cout<<“SHA1Input: “<<status<<endl;

uint8_t Message_Digest[20];
//char Message_Digest[20];

SHA1Result(&sha, Message_Digest);

string sha1_password;
//###############################################

//###############################################
for(int i = 0; i < 20 ; ++i)
{
//printf(“%02X”, Message_Digest[i]); //Ausgabe des SHA1 Hashes
//printf(“%02X”, Message_Digest[i]); //Ausgabe des SHA1 Hashes
//cout << ”  0x” << hex << uppercase << setprecision(2) << setfill(‘0’) << setw(2) << Message_Digest[i];
//cout << ”  0x” << hex << uppercase << Message_Digest[i];
//cout<<i<<endl;
//cout<<Message_Digest[i];
//password_vector.push_back(reinterpret_cast<const char*>(Message_Digest[i]));
//password_vector.push_back((const char*)Message_Digest[i]);
//cout<<hex<<Message_Digest[i];
//printf(“%s”, Message_Digest[i]);
//cout << “0x” << setfill(‘0’) << setw(2) << hex << Message_Digest[i] << endl;
//char_pass = Message_Digest[i];
//strcat(char_pass,(char *)Message_Digest[i]);
//(void)Uart2_Transmit(*char_pass,30,NULL);
//memcpy (char_pass,Message_Digest[i],strlen(Message_Digest[i]));
//Message_Digest[i] = ($ID.text->chars);
//typeName.append(1,*widget);
//Message_Digest[i] = new char char_pass[Message_Digest[i]];
//cout<<Message_Digest[i];
//cout << (unsigned int)Message_Digest[i];
//cout <<hex<< (unsigned int)Message_Digest[i];        //So geht die Ausgabe auch

ostringstream sha1_dezimal;
sha1_dezimal << hex << (unsigned int)Message_Digest[i];
sha1_password.append(sha1_dezimal.str());
/*
std::stringstream ConvertStream;
ConvertStream<<    (unsigned int)Message_Digest[i];
ConvertStream>>password;
*/
}
//cout<<sha1_password<<endl;
//cout << “0x” << setfill(‘0’) << setw(2) << hex << 10 << endl;

//printf(“%02X”, Message_Digest[19]);
//password = Message_Digest[19];
//cout<<password[19]<<endl;
//cout<<Message_Digest[19]<<endl;
//################################################################################################

query_string = “INSERT INTO `owncloud`.`oc_users` (`uid`, `password`) VALUES (‘”+ user +” ‘, ‘” + sha1_password +”‘);”;
query = (char *) query_string.c_str();
mysql_status_code=mysql_real_query(mysql_handle,query,(unsigned int) strlen(query));
exit(0);
}

}

mysql_close(mysql_handle);
}

Post Revisions:

Changes:

December 29, 2014 @ 16:41:36Current Revision
Content
  <div class="html"><pre>
//Compile Command: //Compile Command:
//rm -frv mysql_user_check; clear; g++ -g -Wall -o mysql_user_check mysql_user_check.cpp -L/usr/lib64/mysql -lmysqlclient; ./mysql_user_check; //rm -frv mysql_user_check; clear; g++ -g -Wall -o mysql_user_check mysql_user_check.cpp -L/usr/lib64/mysql -lmysqlclient; ./mysql_user_check;
//rm -frv mysql_user_check;clear; g++ -g -c -O2 -Wall -o sha1.o sha1.c ;g++ -g -c -O2 -Wall -o mysql_user_check.o mysql_user_check.cpp; g++ -Wall -g -o mysql_user_check mysql_user_check.o sha1.o -L/usr/lib64/mysql -lmysqlclient;  ./mysql_user_check;  //rm -frv mysql_user_check;clear; g++ -g -c -O2 -Wall -o sha1.o sha1.c ;g++ -g -c -O2 -Wall -o mysql_user_check.o mysql_user_check.cpp; g++ -Wall -g -o mysql_user_check mysql_user_check.o sha1.o -L/usr/lib64/mysql -lmysqlclient; ./mysql_user_check;
  //quick compile command: g++ -g -c -O2 -Wall -o mysql_user_check.o mysql_user_check.cpp; g++ -Wall -g -o mysql_user_check mysql_user_check.o sha1.o -L/usr/lib64/mysql -lmysqlclient;
//TO DO: //TO DO:
//Wenn nur ein Parameter übergeben wird abbruch verhindern.  //Wenn nur ein Parameter &#252;bergeben wird, Abbruch verhindern.
  //Assert einbauen
  //via Samba Home Share mounten
  //LDAP Abgleichs Check welche AD User vailde sind und welche nicht und ggf. aus DB l&#246;schen.
#include &lt;mysql/mysql.h&gt; #include &lt;mysql/mysql.h&gt;
#include &lt;stdio.h&gt; #include &lt;stdio.h&gt;
#include &lt;iostream&gt; #include <span class="htmlTagDelimiter" >&lt;</span><span class="htmlElementName" >iostream</span><span class="htmlTagDelimiter" >&gt;</span>
#include &lt;string.h&gt; #include &lt;string.h&gt;
#include &lt;stdlib.h&gt; #include &lt;stdlib.h&gt;
#include &lt;vector&gt;  
#include &lt;iomanip&gt;  
  #include <span class="htmlTagDelimiter" >&lt;</span><span class="htmlElementName" >vector</span><span class="htmlTagDelimiter" >&gt;</span>
  #include <span class="htmlTagDelimiter" >&lt;</span><span class="htmlElementName" >iomanip</span><span class="htmlTagDelimiter" >&gt;</span>
  #include <span class="htmlTagDelimiter" >&lt;</span><span class="htmlElementName" >cstdio</span><span class="htmlTagDelimiter" >&gt;</span>
  #include <span class="htmlTagDelimiter" >&lt;</span><span class="htmlElementName" >sstream</span><span class="htmlTagDelimiter" >&gt;</span>
#include &lt;cstdio&gt;  #include &quot;sha1.h&quot;
#include &lt;sstream&gt;  
#include "sha1.h"  
using namespace std; using namespace std;
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
//Via ARGV, Passwort aus PHP nach CPP übergeben.   //Via ARGV, Passwort aus PHP nach CPP &#252;bergeben.
  
MYSQL *mysql_handle;   MYSQL *mysql_handle;
MYSQL_RES *result;   MYSQL_RES *result;
MYSQL_ROW row;   MYSQL_ROW row;
char *query;   char *query;
int mysql_status_code;   int mysql_status_code;
int reihen_nummer;   int reihen_nummer;
int zellen_nummer;   int zellen_nummer;
mysql_handle = mysql_init(NULL);   mysql_handle = mysql_init(NULL);
//cout&lt;&lt;"Mysql Handle: "&lt;&lt;mysql_ handle&lt;&lt;endl;   //cout&lt;&lt;&quot;Mysql Handle: &quot;&lt;&lt; mysql_handle&lt;&lt;endl;
//mysql_real_ connect(mysql_ handle,"127.0.0.1" ,"root","Passwort!","test_ datenbank",0,NULL,0);   //mysql_real_ connect(mysql_ handle,&quot; 127.0.0.1&quot; ,&quot;root&quot; ,&quot;Passwort!&quot;,&quot; test_datenbank&quot;,0,NULL,0);
mysql_real_connect( mysql_handle," 127.0.0.1"," root","Passwort!" ,"owncloud",0,NULL,0);  
   mysql_real_connect( mysql_handle,&quot; 127.0.0.1&quot; ,&quot;root&quot; ,&quot;Passwort!&quot; ,&quot;owncloud3&quot;,0,NULL,0);
  
//query="SELECT * FROM `owncloud`.`oc_users`;";  //query=&quot;SELECT * FROM `owncloud3`.`oc_ users`;&quot;;
//query="INSERT INTO `owncloud`.`oc_users` (`uid`, `password`) VALUES ('USER', '60c6d277a8bd81de7fdde19201bf9c58a3df08f4');";   //query=&quot;INSERT INTO `owncloud3`.`oc_users` (`uid`, `password`) VALUES ('USER', '60c6d277a8bd81de7fdde19201bf9c58a3df08f4');&quot;;
//query="SELECT * FROM `owncloud`.`oc_users` WHERE uid='test2';";   //query=&quot;SELECT * FROM `owncloud3`.`oc_users` WHERE uid='test2';&quot;;
//cout&lt;&lt;"User: "&lt;&lt;argv[1]&lt;&lt;"\n";  
   //cout&lt;&lt;&quot;User: &quot;&lt;&lt; argv[1]&lt;&lt; &quot;\n&quot;;
  
string user;   string user;
user=argv[1];   user=argv[1];
string password;   string password;
password=argv[2];   password=argv[2];
//cout&lt;&lt;"USER: "&lt;&lt;user&lt;&lt;"\n";  
//cout&lt;&lt;"Passowrd: "&lt;&lt;password&lt;&lt;"\n";  
   //cout&lt;&lt;&quot;USER: &quot;&lt;&lt; user&lt;&lt;&quot;\n&quot;;
   //cout&lt;&lt; &quot;Passowrd: &quot;&lt;&lt; password&lt;&lt; &quot;\n&quot;;
string query_string;   string query_string;
query_string = "SELECT * FROM `owncloud`.`oc_users` WHERE uid='" + user + "';";   query_string = &quot;SELECT * FROM `owncloud3`.`oc_users` WHERE uid='&quot; + user + &quot;';&quot;;
//query_string = "INSERT INTO `owncloud`.`oc_users` (`uid`, `password`) VALUES ('" + user + "', '" + password + "');";   //query_string = &quot;INSERT INTO `owncloud3`.`oc_users` (`uid`, `password`) VALUES ('&quot; + user + &quot;', '&quot; + password + &quot;');&quot;;
query = (char *) query_string.c_str();  
   query = (char *) query_string.c_str();
  
//cout&lt;&lt;"SQL Query: "&lt;&lt;query&lt;&lt;endl;   //cout&lt;&lt;&quot;SQL Query: &quot;&lt;&lt; query&lt;&lt;endl;
mysql_status_ code=mysql_real_ query(mysql_ handle,query,(unsigned int) strlen(query));  
  
   mysql_status_ code=mysql_real_ query(mysql_ handle,query,(unsigned int) strlen(query));
//cout&lt;&lt;"mysql status code: "&lt;&lt;mysql_ status_code&lt;&lt;endl;   //cout&lt;&lt;&quot;mysql status code: &quot;&lt;&lt; mysql_status_ code&lt;&lt;endl;
  
if (mysql_status_code &gt; 0)   if (mysql_status_code &gt; 0)
{  
   {
//cout&lt;&lt;"Fehler mit dem SQL Server: "&lt;&lt;mysql_ error(mysql_handle) &lt;&lt;endl;;   //cout&lt;&lt; &quot;Fehler mit dem SQL Server: &quot;&lt;&lt; mysql_error(mysql_handle) &lt;&lt;endl;;
}  
   }
   else
   {
   //cout&lt;&lt;&quot;Query erfolgreich !!&quot;&lt;&lt;endl;
   }
  
   result=mysql_ use_result(mysql_handle);
   //cout&lt;&lt;&quot;MYsql Result: &quot;&lt;&lt; result&lt;&lt;endl;
   //cout&lt;&lt;&quot;Filed count: &quot;&lt;&lt; mysql_field_count&lt;&lt; endl&lt;&lt;endl;
   for(reihen_nummer= 0;reihen_nummer&lt;=mysql_ field_count(mysql_handle) ;reihen_nummer++)
   {
   row=mysql_fetch_ row(result);
   //cout&lt;&lt;&quot;row: &quot;&lt;&lt; row&lt;&lt;endl;
   /*
   if(row==0)
   {
   cout&lt;&lt;&quot;Ende des Datenbank Inhalts !!&quot;&lt;&lt;endl;
   break;
   }
   */
   /*
   for(zellen_nummer=0; zellen_nummer &lt; mysql_num_fields(result); zellen_nummer++)
   {
   cout&lt;&lt;&quot; Zelleninhalt: &quot;&lt;&lt; row[zellen_nummer]&lt;&lt;endl;
   //Check ob User Bereits in Datenbank, wenn ja nichts machen wenn nicht eintragen
   }
  
   cout&lt;&lt;endl;
   */
   if (row &gt; 0)
   {
   //cout&lt;&lt; &quot;Gefunden\n&quot;;
   //Wenn gefunden nichts machen
   exit(0);
   }
else   else
{  
//cout&lt;&lt;"Query erfolgreich !!"&lt;&lt;endl;   
}  
result=mysql_ use_result(mysql_handle);   
//cout&lt;&lt;"MYsql Result: "&lt;&lt;result&lt;&lt;endl;   
//cout&lt;&lt;"Filed count: "&lt;&lt;mysql_ field_count&lt; &lt;endl&lt;&lt;endl;   
for(reihen_nummer= 0;reihen_nummer&lt;=mysql_ field_count(mysql_handle) ;reihen_nummer++)   
{  
row=mysql_fetch_ row(result);   
cout&lt;&lt;"row: "&lt;&lt;row&lt;&lt;endl;   
/*  
if(row==0)   
{  
cout&lt;&lt;"Ende des Datenbank Inhalts !!"&lt;&lt;endl;   
break;   
}  
   {
   //cout&lt;&lt;&quot;NICHT Gefunden\n&quot;;
   //Wenn nicht gefunden user anlegen. SHA1 Engine anbinden.
   //################################################################################################
   SHA1Context sha; //SHA1 wird initialisiert
   //char text[] = {&quot;user&quot;}; //Klartext String der berechnet werden soll
   char *text = {(char *) password.c_str()}; //Klartext String der berechnet werden soll
   //cout&lt;&lt;&quot;SHA1 Klartext: &quot;&lt;&lt; text&lt;&lt;endl;
   int status = 0;
   //cout&lt;&lt; &quot;Textlaenge: &quot;&lt;&lt; strlen(text)&lt;&lt;endl;
   status = SHA1Reset(&amp;sha);
   //cout&lt;&lt; &quot;SHA1Reset: &quot;&lt;&lt; status&lt;&lt;endl;
   status = SHA1Input(&amp;sha,(const unsigned char *) text, strlen(text)); //Klartext Daten werden berechnet
   //cout&lt;&lt; &quot;SHA1Input: &quot;&lt;&lt; status&lt;&lt;endl;
   uint8_t Message_Digest[20];
   //char Message_Digest[20];
   SHA1Result(&amp;sha, Message_Digest);
  
   string sha1_password;
   //###############################################
  
   //###############################################
   for(int i = 0; i &lt; 20 ; ++i)
   {
   //printf(&quot;%02X&quot;, Message_Digest[i]); //Ausgabe des SHA1 Hashes
   //printf(&quot;%02X&quot;, Message_Digest[i]); //Ausgabe des SHA1 Hashes
   //cout &lt;&lt; &quot; 0x&quot; &lt;&lt; hex &lt;&lt; uppercase &lt;&lt; setprecision(2) &lt;&lt; setfill('0') &lt;&lt; setw(2) &lt;&lt; Message_Digest[i];
   //cout &lt;&lt; &quot; 0x&quot; &lt;&lt; hex &lt;&lt; uppercase &lt;&lt; Message_Digest[i];
   //cout&lt;&lt; i&lt;&lt;endl;
   //cout&lt;&lt; Message_Digest[i];
   //password_vector.push_ back(reinterpret_ cast&lt;const char*&gt;(Message_ Digest[i]));
   //password_vector.push_back((const char*)Message_Digest[i]);
   //cout&lt;&lt; hex&lt;&lt;Message_Digest[i];
   //printf(&quot;%s&quot;, Message_Digest[i]);
   //cout &lt;&lt; &quot;0x&quot; &lt;&lt; setfill('0') &lt;&lt; setw(2) &lt;&lt; hex &lt;&lt; Message_Digest[i] &lt;&lt; endl;
   //char_pass = Message_Digest[i];
   //strcat(char_pass,(char *)Message_Digest[i]);
   //(void)Uart2_ Transmit(*char_ pass,30,NULL);
   //memcpy (char_pass,Message_ Digest[i],strlen(Message_ Digest[i]));
   //Message_Digest[i] = ($ID.text-&gt;chars);
   //typeName.append(1,*widget);
   //Message_Digest[i] = new char char_pass[Message_Digest[i]];
   //cout&lt;&lt; Message_Digest[i];
   //cout &lt;&lt; (unsigned int)Message_Digest[i];
   //cout &lt;&lt;hex&lt;&lt; (unsigned int)Message_Digest[i]; //So geht die Ausgabe auch
  
   ostringstream sha1_dezimal;
   sha1_dezimal &lt;&lt; hex &lt;&lt; (unsigned int)Message_Digest[i];
   sha1_password.append( sha1_dezimal.str());
   /*
   std::stringstream ConvertStream;
   ConvertStream&lt;&lt; (unsigned int)Message_Digest[i];
   ConvertStream&gt; &gt;password;
*/   */
/*  
for(zellen_nummer=0; zellen_nummer &lt; mysql_num_fields(result); zellen_nummer++)   
{  
cout&lt;&lt;" Zelleninhalt: "&lt;&lt;row[zellen_ nummer]&lt;&lt;endl;   
//Check ob User Bereits in Datenbank, wenn ja nichts machen wenn nicht eintragen   
}  
cout&lt;&lt;endl;   
*/  
if (row &gt; 0)   
{  
cout&lt;&lt;" Gefunden\n";  
//Wenn gefunden nichts machen   
exit(0);   
}  
else  
{  
cout&lt;&lt;"NICHT Gefunden\n";  
//Wenn nicht gefunden user anlegen. SHA1 Engine anbinden.   
//################################################################################################  
SHA1Context sha; //SHA1 wird initialisiert   
//char text[] = {"Alexander"}; //Klartext String der berechnet werden soll   
char *text = {(char *) password.c_str()}; //Klartext String der berechnet werden soll   
//cout&lt;&lt;"SHA1 Klartext: "&lt;&lt;text&lt;&lt;endl;   
int status = 0;   
//cout&lt;&lt; "Textlaenge: "&lt;&lt;strlen( text)&lt;&lt;endl;   
status = SHA1Reset(&amp;sha);   
//cout&lt;&lt;"SHA1Reset: "&lt;&lt;status&lt;&lt;endl;   
status = SHA1Input(&amp;sha,(const unsigned char *) text, strlen(text)); //Klartext Daten werden berechnet   
//cout&lt;&lt;"SHA1Input: "&lt;&lt;status&lt;&lt;endl;   
uint8_t Message_Digest[20];   
//char Message_Digest[20];   
SHA1Result(&amp;sha, Message_Digest);   
string sha1_password;   
//###############################################   
//###############################################  
for(int i = 0; i &lt; 20 ; ++i)   
{  
//printf("%02X", Message_Digest[i]); //Ausgabe des SHA1 Hashes   
//printf("%02X", Message_Digest[i]); //Ausgabe des SHA1 Hashes  
//cout &lt;&lt; 0x" &lt;&lt; hex &lt;&lt; uppercase &lt;&lt; setprecision(2) &lt;&lt; setfill('0') &lt;&lt; setw(2) &lt;&lt; Message_Digest[i];   
//cout &lt;&lt; 0x" &lt;&lt; hex &lt;&lt; uppercase &lt;&lt; Message_Digest[i];   
//cout&lt;&lt; i&lt;&lt;endl;   
//cout&lt;&lt; Message_Digest[i];   
//password_vector.push_ back(reinterpret_ cast&lt;const char*&gt;(Message_ Digest[i]));   
//password_vector.push_back((const char*)Message_Digest[i]);   
//cout&lt;&lt; hex&lt;&lt;Message_Digest[i];   
//printf("%s", Message_Digest[i]);  
//cout &lt;&lt; "0x" &lt;&lt; setfill('0') &lt;&lt; setw(2) &lt;&lt; hex &lt;&lt; Message_Digest[i] &lt;&lt; endl;   
//char_pass = Message_Digest[i];   
//strcat(char_pass,(char *)Message_Digest[i]);   
//(void)Uart2_ Transmit(*char_ pass,30,NULL);   
//memcpy (char_pass,Message_ Digest[i],strlen(Message_ Digest[i]));   
//Message_Digest[i] = ($ID.text-&gt;chars);   
//typeName.append(1,*widget);   
//Message_Digest[i] = new char char_pass[Message_Digest[i]];   
//cout&lt;&lt; Message_Digest[i];  
//cout &lt;&lt; (unsigned int)Message_Digest[i];   
//cout &lt;&lt;hex&lt;&lt; (unsigned int)Message_Digest[i];        //So geht die Ausgabe auch   
ostringstream sha1_dezimal;   
sha1_dezimal &lt;&lt; hex &lt;&lt; (unsigned int)Message_Digest[i];   
sha1_password.append( sha1_dezimal.str());   
/*  
std::stringstream ConvertStream;   
ConvertStream&lt;&lt;    (unsigned int)Message_Digest[i];   
ConvertStream&gt; &gt;password;   
*/  
}  
   }
//cout&lt;&lt; sha1_password&lt;&lt;endl;   //cout&lt;&lt; sha1_password&lt;&lt;endl;
//cout &lt;&lt; "0x" &lt;&lt; setfill('0') &lt;&lt; setw(2) &lt;&lt; hex &lt;&lt; 10 &lt;&lt; endl;   //cout &lt;&lt; &quot;0x&quot; &lt;&lt; setfill('0') &lt;&lt; setw(2) &lt;&lt; hex &lt;&lt; 10 &lt;&lt; endl;
//printf("%02X", Message_Digest[19]);   //printf(&quot;%02X&quot;, Message_Digest[19]);
//password = Message_Digest[19];   //password = Message_Digest[19];
//cout&lt;&lt; password[19]&lt;&lt;endl;   //cout&lt;&lt; password[19]&lt;&lt;endl;
//cout&lt;&lt; Message_Digest[19]&lt;&lt;endl;   //cout&lt;&lt; Message_Digest[19]&lt;&lt;endl;
//################################################################################################   //################################################################################################
  
query_string = "INSERT INTO `owncloud`.`oc_users` (`uid`, `password`) VALUES ('"+ user +" ', '" + sha1_password +"');";   query_string = &quot;INSERT INTO `owncloud3`.`oc_users` (`uid`, `password`) VALUES ('&quot;+ user +&quot; ', '&quot; + sha1_password +&quot;');&quot;;
query = (char *) query_string.c_str();   
   query = (char *) query_string.c_str();
mysql_status_ code=mysql_real_ query(mysql_ handle,query,(unsigned int) strlen(query));   mysql_status_ code=mysql_real_ query(mysql_ handle,query,(unsigned int) strlen(query));
exit(0);   exit(0);
}  
}  
   }
  
   }
  
mysql_close(mysql_handle);   mysql_close(mysql_handle);
  
   //Home Shares via Samba in User Verzeichnis mounten.
   //Kommando: mount -t cifs //wdf-filer02/user$ //usr/local/apache2/ htdocs/owncloud/ data/user.user\@domain.net/ files/home_share/ -o user=user,uid=daemon
   //schauen ob homeshare schon gemounted.
  
   //system(&quot;mount -t cifs //wdf-filer02/user$ //usr/local/apache2/ htdocs/owncloud/ data/user.user\@domain.net/ files/home_share/ -o user=user,uid= daemon&quot;);
  
} }
  </pre></div>

Note: Spaces may be added to comparison text to allow better line wrapping.