memcpy "segmentation fault". Verlagerung der Datenstruktur Grenzen

Ich versuche zu Debuggen dieser Fehler aber nicht in der Lage, es zu tun für eine Weile jetzt. Ich habe versucht, verwenden Sie memmove als alternative aber auch dass die Ergebnisse in einem segmentation fault.
Der link zu dem code, der in dieser Frage ist verfasst am - http://pastebin.com/hiwV5G04

Kann mir bitte jemand helfen zu verstehen, was mache ich falsch ?

//------------------------------------------------------------------------
//Somewhere in the main function, This is the piece of code I am executing
//------------------------------------------------------------------------
SslDecryptSession *ssl_session = malloc(sizeof(struct _SslDecryptSession ));
ssl_session->client_random.data = NULL;  //Make the stuff point somewhere. Else can use malloc also here. Not sure if this is a problem
ssl_session->server_random.data= NULL;
const u_char *payload;                  /* Packet payload */
//Case for client random
printf("Client Random ");
for (cs_id = 11; cs_id < 43; cs_id++){
printf("%hhX", payload[cs_id] );
}
printf("\n");
cs_id=11;
ssl_session->client_random.data_len=32;
//Segmentation fault here
memcpy(ssl_session->client_random.data, payload[cs_id], 32);

Den Definitionen der Strukturen beteiligt sind -

typedef struct _SslDecryptSession {
guchar _master_secret[SSL_MASTER_SECRET_LENGTH];
guchar _session_id[256];
guchar _client_random[32];
guchar _server_random[32];
StringInfo session_id;
StringInfo session_ticket;
StringInfo server_random;
StringInfo client_random;
StringInfo master_secret;
StringInfo handshake_data;
StringInfo pre_master_secret;
guchar _server_data_for_iv[24];
StringInfo server_data_for_iv;
guchar _client_data_for_iv[24];
StringInfo client_data_for_iv;

gint state;
SslCipherSuite cipher_suite;
SslDecoder *server;
SslDecoder *client;
SslDecoder *server_new;
SslDecoder *client_new;
gcry_sexp_t private_key;
StringInfo psk;
guint16 version_netorder;
 StringInfo app_data_segment;
    SslSession session;
} SslDecryptSession;


typedef struct _StringInfo {
    guchar  *data;         
    guint    data_len;  
   } StringInfo

Die Ausgabe von gdb ist das

b 1985    //Putting a break point at line 1985 in my source code. 
//Here this is eqvialent to line 83, that is "ssl_session->client_random.data_len=32;"
Breakpoint 1 at 0x403878: file Newversion.c, line 1985.
run       //run the code in gdb
At breakpoint 1 the following info is in the variables
p ssl_session
$1 = (SslDecryptSession *) 0x60fc50   //I put some data in ssl_session->version_netorder earlier. So it is not null here. Everything works fine here
p ssl_session->client_random.data
$2 = (guchar *) 0x0
p ssl_session->client_random.data_len
$3 = 32
step  //Execute 1 more line in the code
//I reach at the memcpy line and I get this error then
Breakpoint 1, got_packet (args=0x0, header=0x7fffffffe2c0, packet=0x7ffff6939086 "P=\345\203\376\177") at Newversion.c:1995
1995                memcpy(ssl_session->client_random.data, payload[cs_id], 32);
(gdb) 
(gdb) s
__memcpy_sse2_unaligned () at ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S:27
27  ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S: No such file or directory.
(gdb) 
28  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 
29  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 
30  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 
31  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 
32  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 
33  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 
34  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 
35  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S
(gdb) 

Program received signal SIGSEGV, Segmentation fault.
__memcpy_sse2_unaligned () at ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S:35
35  in ../sysdeps/x86_64/multiarch/memcpy-sse2-unaligned.S

Haben Sie versucht, und das Profil der code mit Valgrind und versuchen Sie ein Analyse-tool in einer IDE? Sie haben 0 compiler-Warnungen?
Ich habe diese compiler-Warnung

Newversion.c:2044:65: warning: passing argument 2 of ‘memcpy’ makes pointer from integer without a cast [-Wint-conversion]                          memcpy(ssl_session->server_random.data, payload[cs_id], 33);

` ^In der Datei enthalten, aus Newversion.c:39:0: /usr/include/string.h:42:14: Anmerkung: expected "const void * restrict", aber argument ist vom Typ 'u_char {aka const unsigned char}' extern void *memcpy (void *__restrict __ - dest, const void *__restrict __src `
Sie vergessen, & : memcpy(ssl_session->client_random.Daten &Nutzlast[cs_id], 32);
Ich habe versucht Sie das zweite argument der memcpy dieser memcpy(ssl_session->client_random.Daten -, payload+11, 32) gibt Es keine compiler-Warnungen nach dieser Bearbeiten Diese sollte die gleiche sein, mit dem '&', Aber entweder Sie funktionieren nicht, und noch am Ende in mem Ausrichtungen

InformationsquelleAutor Choi | 2016-05-07

2

Es gibt viele Dinge, die nicht richtig scheint mit dem code. Die problematische Zeile ist :
```
memcpy(ssl_session->client_random.data, payload[cs_id], 32);
```
Diese Zeile kopieren, was zeigte Nutzlast[cs_id] an der Adresse zeigte ssl_session->client_random.Daten. Wird diese 32 bytes.

Ihnen die Inhalte zur Verfügung gestellt von Nutzlast zu memcpy statt der Adresse, daher die Warnung erhalten Sie bei der Kompilierung.

Sie meinte wohl so etwas wie
```
memcpy(ssl_session->client_random.data, &payload[cs_id], 32); //Note the & symbol
```
Gibt es auch einen Kommentar in deinem code besagt, dass Sie unsicher sind, ob Sie sollten malloc oder nicht. Sie tun.

In das code-snippet Sie bereitgestellt, payload nicht initilized (daher unberechenbar Wert) und ssl_session->client_random.Daten initilized mit NULL. Dies bedeutet, dass Sie versuchen, zu schreiben auf Adresse 0, die heben einen segfault sicher. Außerdem, vor dem schreiben auf Adresse 0, Sie Lesen eine zufällige Adresse im Speicher, die wahrscheinlich zu einer Ausnahme als gut.

Um das Problem zu lösen, stellen Sie sicher, Ihre OS gegeben hat, die Ihnen einen Speicherplatz zu verwenden, vor dem Lesen/schreiben.
```
const u_char payload[43];  //43 is based on the example you provided
...
ssl_session->client_random.data = malloc(sizeof(u_char)*32); //Also based on your example
...
memcpy(ssl_session->client_random.data, &payload[cs_id], 32);
```
Hoffe, das hilft.

Ja. Dieser arbeitete. Danke. Ich schaffte es, die seg-fault aus dem Weg. Ich glaube, der Grund war nicht die Initialisierung der Variablen.
Gut zu wissen. Markieren Sie bitte als Lösung, wenn Sie Ihr Problem behoben!

InformationsquelleAutor Pier-Yves Lessard
0

Den fehlerhaften code ist:
```
memcpy(ssl_session->client_random.data, payload[cs_id], 32);
```
Mit payload definiert als:
```
const u_char *payload;
```
Scheinen Sie zu haben, ein Typenkonflikt für operand 2 memcpy Sie nicht einen Zeiger übergeben, sondern eine ganze Zahl. Sollte der compiler sich beschweren, mit einer Warnung, und diese Warnungen sollten nicht ignoriert werden.

Meinst du zu verwenden memset() zum initialisieren der Daten statt memcpy()?

Ich änderte den code zu diesem memcpy(ssl_session->client_random.Daten -, payload+11, 32); welche Veränderungen es auf einen Zeiger. Aber es gibt noch ein seg fault gibt Es keine compiler-Warnungen, nachdem Sie diese Bearbeiten.
Nicht wirklich, ich initialisiert ssl_session->client_random zu NULL und die nächsten 32 bytes payload[cs_id] sind in Ordnung und die Daten enthalten. Ich Schreibe Sie oben in eine for-Schleife.

InformationsquelleAutor chqrlie

1-Sie vergessen den Speicher.

2 - memcpy(ssl_session->client_random.Daten &Nutzlast[cs_id], 32*sizeof(u_char)

    SslDecryptSession *ssl_session = malloc(sizeof(struct _SslDecryptSession ));
    ssl_session->client_random.data = NULL;  //Make the stuff point somewhere. Else can use malloc also here. Not sure if this is a problem
    ssl_session->server_random.data= NULL;

    const u_char *payload;                  /* Packet payload */
    //Case for client random

    printf("Client Random ");
    for (cs_id = 11; cs_id < 43; cs_id++){
            printf("%hhX", payload[cs_id] );
    }
    printf("\n");


    cs_id=11;
    ssl_session->client_random.data_len=32;
    guchar  *pData = malloc(32*sizeof(guchar));  
    ssl_session->client_random.data = pData;
    memcpy(ssl_session->client_random.data, &payload[cs_id], 32*sizeof(u_char);

Danke. Die Zuordnung der Speicher war der Grund, warum mein code nicht funktioniert
ok, Gut zu wissen pls markieren Sie die Frage als gelöst oder fügen Sie Ihre eigene Lösung

InformationsquelleAutor fedi

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.