static int Verify_Sign(const_longnum_ptr mdc, const_longnum_ptr r,
const_longnum_ptr s, const_longnum_ptr y) {
/*>>>> <<<<*
*>>>> AUFGABE: Verifizieren einer El-Gamal-Signatur <<<<*
*>>>> <<<<*/
longnum gleich_links, gleich_rechts;
LInitNumber(&gleich_links, NBITS(&p), 0);
LInitNumber(&gleich_rechts, NBITS(&p), 0);
LModMultExp(y, r, r, s, &gleich_links, &p);
LModExp(&w, mdc, &gleich_rechts, &p);
if (!LCompare(&gleich_links, &gleich_rechts))
return 1;
else
return 0;
}
inline int String0::Compare(const String0& s) const
{
#ifdef FAST_STRING_COMPARE
if((chr[KIND] | s.chr[KIND]) == 0) {
#ifdef CPU_64
uint64 a64 = SwapEndian64(q[0]);
uint64 b64 = SwapEndian64(s.q[0]);
if(a64 != b64)
return a64 < b64 ? -1 : 1;
uint32 a32 = SwapEndian32(w[2]);
uint32 b32 = SwapEndian32(s.w[2]);
if(a32 != b32)
return a32 < b32 ? -1 : 1;
#else
uint32 a32 = SwapEndian32(w[0]);
uint32 b32 = SwapEndian32(s.w[0]);
if(a32 != b32)
return a32 < b32 ? -1 : 1;
a32 = SwapEndian32(w[1]);
b32 = SwapEndian32(s.w[1]);
if(a32 != b32)
return a32 < b32 ? -1 : 1;
a32 = SwapEndian32(w[2]);
b32 = SwapEndian32(s.w[2]);
if(a32 != b32)
return a32 < b32 ? -1 : 1;
#endif
uint16 a16 = SwapEndian16(v[6]);
uint16 b16 = SwapEndian16(s.v[6]);
if(a16 != b16)
return a16 < b16 ? -1 : 1;
return 0;
}
#endif
return LCompare(s);
}
inline int String0::Compare(const String0& s) const
{
#ifdef FAST_STRING_COMPARE
if((chr[KIND] | s.chr[KIND]) == 0) {
#ifdef CPU_64
uint64 a64 = q[0];
uint64 b64 = s.q[0];
if(a64 != b64)
return SwapEndian64(a64) < SwapEndian64(b64) ? -1 : 1;
uint32 a32 = w[2];
uint32 b32 = s.w[2];
if(a32 != b32)
return SwapEndian32(a32) < SwapEndian32(b32) ? -1 : 1;
#else
uint32 a32 = w[0];
uint32 b32 = s.w[0];
if(a32 != b32)
return SwapEndian32(a32) < SwapEndian32(b32) ? -1 : 1;
a32 = w[1];
b32 = s.w[1];
if(a32 != b32)
return SwapEndian32(a32) < SwapEndian32(b32) ? -1 : 1;
a32 = w[2];
b32 = s.w[2];
if(a32 != b32)
return SwapEndian32(a32) < SwapEndian32(b32) ? -1 : 1;
#endif
uint16 a16 = v[6];
uint16 b16 = s.v[6];
if(a16 != b16)
return SwapEndian16(a16) < SwapEndian16(b16) ? -1 : 1;
return 0;
}
#endif
return LCompare(s);
}
int main(int argc, char **argv) {
Connection con;
int cnt, ok;
Message msg, new_msg;
longnum x, Daemon_y, mdc, new_mdc;
const char *OurName = "mima";
/************** Laden der öffentlichen und privaten Daten ***************/
if (!Get_Privat_Key(NULL, &p, &w, &x)
|| !Get_Public_Key(DAEMON_NAME, &Daemon_y))
exit(0);
LSeed(GetCurrentTime());
/******************** Verbindung zum Dämon aufbauen *********************/
//OurName = MakeNetName(NULL); /* gibt in Wirklichkeit Unix-Gruppenname zurück! */
if (strlen(OverrideNetName) > 0) {
OurName = OverrideNetName;
}
if (!(con = ConnectTo(OurName, DAEMON_NAME))) {
fprintf(stderr, "Kann keine Verbindung zum Daemon aufbauen: %s\n",
NET_ErrorText());
exit(20);
}
/*********** Message vom Typ ReportRequest initialisieren ***************/
msg.typ = ReportRequest; /* Typ setzten */
strcpy(msg.body.ReportRequest.Name, OurName); /* Gruppennamen eintragen */
Generate_MDC(&msg, &p, &mdc); /* MDC generieren ... */
Generate_Sign(&mdc, &msg.sign_r, &msg.sign_s, &x); /* ... und Nachricht unterschreiben */
/************* Nachricht abschicken, Antwort einlesen *******************/
if (Transmit(con, &msg, sizeof(msg)) != sizeof(msg)) {
fprintf(stderr, "Fehler beim Senden des 'ReportRequest': %s\n",
NET_ErrorText());
exit(20);
}
if (Receive(con, &msg, sizeof(msg)) != sizeof(msg)) {
fprintf(stderr, "Fehler beim Empfang des 'ReportResponse': %s\n",
NET_ErrorText());
exit(20);
}
/****************** Überprüfen der Dämon-Signatur ***********************/
printf("Nachricht vom Dämon:\n");
for (cnt = 0; cnt < msg.body.ReportResponse.NumLines; cnt++) {
printf("\t%s\n", msg.body.ReportResponse.Report[cnt]);
}
Generate_MDC(&msg, &p, &mdc);
ok = Verify_Sign(&mdc, &msg.sign_r, &msg.sign_s, &Daemon_y);
if (ok)
printf("Dämon-Signatur ist ok!\n");
else {
printf("Dämon-Signatur ist FEHLERHAFT!\n");
return 0;
}
/*>>>> <<<<*
*>>>> AUFGABE: Fälschen der Dämon-Signatur <<<<*
*>>>> <<<<*/
printf("Begin zu fälshen:\n");
memset(&new_msg, 0, sizeof(Message));
new_msg.typ = VerifyRequest;
generateMsg(&new_msg);
toFitMDC(&new_msg, &msg);
Generate_MDC(&new_msg, &p, &new_mdc);
if (!LCompare(&mdc, &new_mdc)) {
printf("Fälschung fertig!\n");
LCpy(&new_msg.sign_r, &msg.sign_r);
LCpy(&new_msg.sign_s, &msg.sign_s);
if (!(con = ConnectTo(OurName, DAEMON_NAME))) {
fprintf(stderr, "Kann keine Verbindung zum Daemon aufbauen: %s\n",
NET_ErrorText());
exit(20);
}
if (Transmit(con, &new_msg, sizeof(new_msg)) != sizeof(new_msg)) {
fprintf(stderr, "Fehler beim Senden des 'VerifyRequest': %s\n",
NET_ErrorText());
exit(20);
}
if (Receive(con, &msg, sizeof(msg)) != sizeof(msg)) {
fprintf(stderr, "Fehler beim Empfang des 'VerifyResponse': %s\n",
NET_ErrorText());
exit(20);
}
printf("Nachricht vom Dämon:\n");
printf("\t%s\n", msg.body.VerifyResponse.Res);
} else
printf("Fälschung gescheitert\n");
return 0;
}
void handle_connection (Connection con, const char *peer, const char *now)
{
char tmps[33];
unsigned char mdc[16];
unsigned long tmp;
int genexp = 1;
longnum y;
struct message in, out;
int l;
struct timeval t;
struct tms t_times;
out.type = SC_Modulus;
memcpy (&out.body.sc_modulus.n, &n, sizeof(n));
fprintf (stderr, "-> %s: SC_Modulus\n", peer);
fflush (stderr);
Transmit (con, &out, sizeof (out));
while (1) {
if ((l=Receive (con, &in, sizeof (in))) != sizeof (in)) {
if (! l) {
fprintf (stderr, "<- %s: connection closed\n", peer);
} else {
fprintf (stderr, "<- %s: receive %d instead of %lu\n", peer, l, sizeof(in));
}
fflush (stderr);
return;
}
if (genexp) {
MD5_CTX c;
fprintf (stderr, "-- %s: Generating new exponent\n", peer);
fflush (stderr);
/* XXX Zufaelligen Exponenten erzeugen ... */
genexp = 0;
}
switch (in.type) {
case CS_Exp:
/* fprintf (stderr, "<- %s: CS_Exp\n", peer); */
out.body.sc_exp_r.timing =
LITModExp (&out.body.sc_exp_r.z, &in.body.cs_exp.x, &y, &n);
out.type = SC_ExpResp;
break;
case CS_Key:
fprintf (stderr, "<- %s: CS_Key ", peer);
memcpy (&out.body.sc_key_r.y, &y, sizeof (y));
out.type = SC_KeyResp;
out.body.sc_key_r.ok = ! LCompare (&y, &in.body.cs_key.y);
if (! out.body.sc_key_r.ok) fprintf (stderr, "not ");
fprintf (stderr, "ok\n");
fflush (stderr);
genexp = 1;
break;
default:
fprintf (stderr, "<- %s: unknown type %d\n", peer, in.type);
fflush (stderr);
return;
}
/* fprintf (stderr, "-> %s: response\n", peer); */
Transmit (con, &out, sizeof (out));
}
}
