Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht Das deutsche QBasic- und FreeBASIC-Forum
Für euch erreichbar unter qb-forum.de, fb-forum.de und freebasic-forum.de!
 
FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen  RegistrierenRegistrieren
ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin
Zur Begleitseite des Forums / Chat / Impressum
Aktueller Forenpartner:

big_int Struktur

 
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC.
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
storky



Anmeldungsdatum: 06.01.2013
Beiträge: 68

BeitragVerfasst am: 20.08.2013, 20:03    Titel: big_int Struktur Antworten mit Zitat

Hallo,

ich würde gerne einen big_int auf die Festplatte speichern, bin mir aber nicht ganz schlüssig über die Struktur. Das ist der Type aus einem der Header:

Code:
type big_int_word as uinteger

type big_int
   num as big_int_word ptr
   sign as sign_type
   len as integer
   len_allocated as integer
end type


Wie komme ich nun an die Daten? z.Z. benutze ich:

Code:

   .myKeys.publicKey.e = big_e
   .myKeys.publicKey.N = big_N
   .myKeys.privateKey.d = big_d
   .myKeys.privateKey.N = big_N
      
   For i As UInteger = 0 to .myKeys.publicKey.e->Len
      Print Hex(.myKeys.publicKey.e->num + i);
   Next


Also .myKeys.publicKey.e ist ein big_int Ptr, len wird klar sein und ist enthält auch einen schlüsigen Wert. Nur num as big_int_word ptr dürfte ein Ptr auf einen Uinteger sein, also 4 Bytes und beim Auslesen lese ich ja die ganze Länge? Da kommen zwar Werte raus und es sieht nicht aus wie nicht allocierter Speicher. Weiß jemand wie das aufgebaut ist? Ich habs auch getestet hatte folgende Werte:

84810838602001819459053156004499419414883114750375898676325375147539793453028260
19162870539214112319782489063804186030184670904039452079796070074046097465013200
03696595046952283533766198360022918933876360094230905461443400606269178504696884
80006090026027594076644069365452248872540627169158293240513892449667043471751931
02097


77FD2877FD2C77FD3077FD3477FD3877FD3C77FD4077FD4477FD4877FD4C77FD5077FD5477FD5877
FD5C77FD6077FD6477FD6877FD6C77FD7077FD7477FD7877FD7C77FD8077FD8477FD8877FD8C77FD
9077FD9477FD9877FD9C77FDA077FDA477FDA877FDAC77FDB0

Also Erster ist die mit big_int_to_str erstelle Dezimalzahl, Zweiter ist meine "als Hex Print" Schlaufe und ich bin leider zu blöd um zu sagen obs die selben Zahlen sind (Glaube aber nein, da "77FD" jeden 2. Wert ausmacht). Der Windows calc nimmt die auch nicht an, der füllt nur 64 Bit auf.

Beziehungsweiße wirds auch nicht der selbe Wert sein da ichs ja Byteweiße auslese... Ist auch Wurst, will ja nur den Speicher dumpen.. da muss ich ja nicht verstehen was ich da mache grinsen

Auch ne Möglichkeit wäre (Vllt sogar die Einfachere?) die Zahl dezimal abzuspeichern und den String wieder zu konvertieren... Hab aber keine Funktion gefunden...

Noch ein Edit: Mir fiel endlich mal auf, dass die Länge weit überschritten wird und klar wegen dem typ.

Mit
Code:
Print Hex(*(Cast (UByte Ptr, .myKeys.publicKey.e->num) + i));


Kommt dann sowas raus: "F793525173CAA5205DC3BCEDD671BBA2716B4E1F3888B66D03583628B804D2BADB6"

Egal, ich warte einfach mal auf ne Antwort bevor ichs noch verwirrender mache.


Zuletzt bearbeitet von storky am 20.08.2013, 20:23, insgesamt einmal bearbeitet
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Jojo
alter Rang


Anmeldungsdatum: 12.02.2005
Beiträge: 9736
Wohnort: Neben der Festplatte

BeitragVerfasst am: 20.08.2013, 20:21    Titel: Antworten mit Zitat

Zunächst wäre sinnvoll zu erwähnen, was du am Schluss haben willst - Text- oder Binärdatei? Falls letzteres, kannst du den TYPE ja direkt 1:1 in die datei schreiben.
_________________
» Die Mathematik wurde geschaffen, um Probleme zu lösen, die es nicht gäbe, wenn die Mathematik nicht erschaffen worden wäre.
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden Website dieses Benutzers besuchen
storky



Anmeldungsdatum: 06.01.2013
Beiträge: 68

BeitragVerfasst am: 20.08.2013, 20:25    Titel: Antworten mit Zitat

Hexadezimal wäre mir aus ästhetischen Gründen lieb happy aber ansonsten ist das egal solange ich es speichern und laden kann. Also binär wäre auch eine Option, bzw könnt ich das ja schnell in Hex konvertieren und zurück wenn ich weiß wo die Binärdaten platziert sind. lächeln
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
storky



Anmeldungsdatum: 06.01.2013
Beiträge: 68

BeitragVerfasst am: 20.08.2013, 22:18    Titel: Antworten mit Zitat

Ich denke ich habs soweit raus mit dem Auslesen lächeln

Man erinnere sich, dass .myKeys.publicKey.e ein big_int ptr ist.

Code:

Print ToStr(.myKeys.publicKey.e)
Print
print
For i As UInteger = 0 to .myKeys.publicKey.e->Len * 4
   Print Hex(*(Cast (UByte Ptr, .myKeys.publicKey.e->num) + i));
Next


Das gibt mir Folgendes:

Zitat:

51419035472063711505818557746607100465945961501567040064078783026622039952100972
29880963450494302249171812251089073087445164308405436000281086312217418110620009
26931240670446845894787008127289910896729282291363463750162164815947374132757125
43747526753927452748108126773167621035863218141109726271965179819399077630968203
9171


83699C921ACD5655D6482074FC5C93F1F4CC3F4D5B74ECEB6C80FC8EF2BA251CB39E6AD4BAD34321
D3FE48D225699A3B6DFDFC55EBDA34558BC8C298241D9BFB4D9474CB897B4919A565A2BAB433A7BF
4CAECB195183DAC6AE3A7655759CB171C858513AA9817D85BC327E812778929499422DE6D4546308
412857EA2E2528D6829A00


Ich habs unter Linux mit BC nachgerechnet und bekomm das hier:

Zitat:
bc 1.06.95
Copyright 1991-1994, 1997, 1998, 2000, 2004, 2006 Free Software Foundation, Inc.
This is free software with ABSOLUTELY NO WARRANTY.
For details type `warranty'.
obase=16
5141903547206371150581855774660710046594596150156704006407878302662203995210097229880
9634504943022491718122510890730874451643084054360002810863122174181106200092693124067
0446845894787008127289910896729282291363463750162164815947374132757125437475267539274
527481081267731676210358632181411097262719651798193990776309682039171

A29688D52E2A27E052801843046456DDE22944929897712E827C35BD81798AA13850\
5C871B19C7555760AE36A0CDA031895B1ECCAF47B3A43AB2B5A569A91B497B84C47D\
9B4BFD94182298CBC5845A3BD0E55FCFD6D3B9A0956228DE40FD32143D3BAD46A9EB\
31C25BAF28EFC806CEBEC745B4D3FCCF4F1935CFC742048D65556CD1A929C6983


Bis auf dass mein Ergebnis 2 Nullen zuviel hat und es invertiert ist wie ein normales dword, hauts hin.
könnte trotzdem Hilfe gebrauchen es wieder in den Speicher zu laden happy

Edit:
Obwohl ich da schon ne Idee hab, müsste ja bloß ein big_int declarieren, den Speicher selbst neu allocieren, beim Auslesen die führende 0 an die Bytes hängen damit ich den wieder so beschrieben kann wies war... oje
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
ThePuppetMaster



Anmeldungsdatum: 18.02.2007
Beiträge: 1839
Wohnort: [JN58JR]

BeitragVerfasst am: 21.08.2013, 09:28    Titel: Antworten mit Zitat

Warum machst du es nicht via String, wie bei den bildaten im parellel thread auch?!

Code:

type bigint
   'blub
end type

dim foo as bigint
dim temp as string
temp = space(sizeof(bigint))
*cast(bigint ptr, @temp[0]) = foo


rückwerts genauso

Code:

type bigint
   'blub
end type

dim foo as bigint
dim temp as string
temp = space(sizeof(bigint))
foo = *cast(bigint ptr, @temp[0])



MfG
TPM
_________________
[ WebFBC ][ OPS ][ ToOFlo ][ Wiemann.TV ]
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
storky



Anmeldungsdatum: 06.01.2013
Beiträge: 68

BeitragVerfasst am: 21.08.2013, 11:41    Titel: Antworten mit Zitat

Gute Frage eigentlich grinsen Wär aufjedenfall das Einfachste. Nur da wär zu beachten, dass sizeof(bigint) = 16 ist da er aus nem ptr und 3 Integern besteht.
Man müsste den String auf big_int.len * 4 spacen, da die Länge in Integern angegeben wird.
Ich glaube ich habs so "kompliziert" gemacht weil ich Ende doch auf Hexadezimal raus und das in einem Rutsch erledigen wollte... und habs damit auch hinbekommen:

Speichern:
Code:

For i As UInteger = 0 to .myKeys.publicKey.e->Len * 4            'Len mal integer größe
   cH = Hex(*(Cast (UByte Ptr, .myKeys.publicKey.e->num) + i))
   If Len(cH) = 1 Then cH = "0" & cH               'Führende 0 um die Bytes wieder trennen zu können
   outPutStr = outPutStr & cH
Next



Laden:
Code:


big_int = loadHexToBigInt(hexStr)

Function loadHexToBigInt(s As String) As big_int Ptr
   Dim bi As big_int Ptr
   bi = big_int_create( 1 )
   bi->num = Callocate(CInt(Len(s) / 2))               '2 hex bytes = 1 byte
   bi->sign = 0
   bi->Len  = Len(s) / 2 / SizeOf(Integer)
   bi->len_allocated = Len(s) / 2
   Dim As UInteger ii
   For i As UInteger = 0 To Len(s) -1 Step 2
      *(Cast(UByte Ptr, bi->num) + ii) = Val("&h" & Mid(s, i + 1, 2))
      ii += 1
   Next
   Return bi
End Function

Dazu muss ich aber sagen, dass es nicht eine hexadezimale Zahl in einen big_int konvertiert sondern nur den Speicherdump einließt.. und der ist invertiert.

Danke aber! lächeln
War keine Absicht den Selstdarrsteller zu mimen, nur öfters denk ich es kann nicht schnell genug gehen Hilfe zu holen, mache aber währenddessen weiter. Wusste Anfangs eigentlich bloß nicht was ein big_int eigentlich ist. Drum werde ich die Stringmethode noch ausarbeiten damit es komplett wird für Googler etc.

Ok, so kann man die Binärdaten in einen String knallen:
Code:

Dim As big_int Ptr bi = big_int_create( 1 )
Dim As String saveStr
saveStr = Space(bi->Len * SizeOf(Integer))
*(Cast(uinteger Ptr, @saveStr)) = bi->num
'Len vom String haut ja hin


Und hier noch der dezimale Weg (hab mir endlich bissel anderen Quelltext mit big_int angesehen... find ich aber doch am kompliziertesten weil man auf die unterschiedlichen Typen und Funktionsnamen festgetackert ist):

Code:
'Von dec String in big_int schreiben:

Dim As big_int Ptr bi = big_int_create( 1 )
Dim As big_int_str Ptr MyString
MyString = big_int_str_create( 1 )
Dim As String zahl = "345678997654300000005"

big_int_str_copy_s( StrPtr( zahl ), Len( Stri ), MyString )
big_int_from_str(MyString, 10, bi)

'Von big_int zu dec String:

Dim As big_int_str Ptr s
s = big_int_str_create( 1 )
big_int_to_str( num, 10, s ) 'num ist big_int ptr
Print *s->Str



Ist schon ne Wissenschaft für sich.

Edit: Und es kann sein, dass es totaler Unsinn ist den Speicher selbst zu allocieren bei:

bi = big_int_create( 1 )
bi->num = Callocate(CInt(Len(s) / 2))

Ich hab nur nicht geguckt ob der Parameter (1) Zufällig die Länge ist zwinkern
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
RockTheSchock



Anmeldungsdatum: 04.04.2007
Beiträge: 138

BeitragVerfasst am: 22.08.2013, 12:22    Titel: Big_int Lib Antworten mit Zitat

Es gibt auch eine big_int lib mit einem Beispiel. Musst dir die lib nur herunterladen und ins lib Verzeichnis kopieren:
http://sourceforge.net/projects/fbc/files/Binaries%20-%20Windows/Libraries/
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    Das deutsche QBasic- und FreeBASIC-Forum Foren-Übersicht -> Allgemeine Fragen zu FreeBASIC. Alle Zeiten sind GMT + 1 Stunde
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.

 Impressum :: Datenschutz