KodeZwergs TIniHelper Klasse

[KodeZwerg]

Es geht um ein kleines mini Projekt was einem dem Umgang mit Ini Dateien hoffentlich positiv erleichtern soll.
In dieser Fassung ist alles noch wie ein Rohdiamant und auch alles noch von außen erreichbar, was später entfernt wird.

Diese Fassung beherrscht nur das lesen und schreiben von Typ String!
Aber dafür mit allen der Klasse bis jetzt zur Verfügung stehenden Features.

hier ein ausschnitt meiner unit, falls ich euer Interesse geweckt haben sollte, alles was man benötigt um loszulegen liegt diesem Anhang bei, nur kein 7Zip entpacker.
Eine Demo liegt nicht bei, da es hoffentlich selbsterklärend ist, feedback dazu wäre Wünschenswert.

Delphi-Quellcode:

(*

Project: Class TIniHelper

Author: KodeZwerg

License: Freeware, Open Source.
         Free to use, if used and you like it a mentioned thankyou in credits would be nice.
         Feedback on one of my running Project sites is also very welcome, in good or bad way!

Description: small Unit to help easy interact with .ini files

features:
 - support autogeneration on many aspects
 - auto-mode supports either locate "X:\Users\UserName\AppData\Local\CurrentExeName\" or folder of CurrentExeName
 - support easy sub-folder usage simply by adding "a sub\folder in\a sub\filename.ext" with or without leading slash
 - you can specify full path + filename if you like else its autogenerated for you
 - simple XOR encryption for ini file internals included if you enable it
 - AES128 encryption for ini file values can be added
 - simple autogenerate password feature for AES128 included
 - easy Password changing possible

Limits:
 - ATM bound to Windows.

Supported Pascal Versions:
 - in theory all, written for >= Delphi 2009
 - Prior Delphis might have trouble with UniCode
 - Delphi with other Namespace will be supported soon

History:
 - created as single methods to test things out
 - added encryption for each method
 - switched to class

current Version:
 - preview release to show whats comming with full access on everything

Status:
 - first open release
 - pre-release has full control on properties, sideeffects very possible!!
 - just included Type String to play with
 - with all above features, you might find out more by happy testing :-]

Bugs:
 - none know ATM... *yay*
 - just missing all other types

Planned:
 - include all missing
 - fix all, like my current datetime convert issue where i prior need to set formatsettings, i hope than all be good with it

Used external Resources:
 - wcrypt2.pas (included)
 - independend AES128 example based on wcrypt2.pas (included)
 - wcrypt2.pas dependend file encryption example (included) that later be used to crypt streams...
   wish me luck ;-)
 - many threads on www.delphipraxis.net and nice discussions with good members over there *thankyou all!*
 - stackoverflow i guess always involved to me :))

Project Sites: (latest file will be same)
 - German Version: https://www.delphipraxis.net/198462-kodezwergs-tinihelper-klasse.html
 - English Version: https://en.delphipraxis.net/topic/175-windows-ini-file-helper-unit/
 - you need to sign up free membership to join discussion or download latest file

*)

type
  TIniHelper = class (TObject)
  private
    FAutoFolder: Boolean;
    FCrypt: Boolean;
    FSectionCrypt: Boolean;
    FIdentCrypt: Boolean;
    FPassword: String;
    FPasskey: Integer;
    FFilename: String;
    FSection: String;
    FIdent: String;
    FPath: String;
    FPathDelimiter: Char;
    FFileExists: Boolean;
    procedure SetFilename( const Filename: String = '' );
  published
    constructor Create( const Filename: string = ''; const AutoFolder: boolean = False; const Password: String = ''; const Crypt: Boolean = False; const Passkey: Integer = 0; const SectionCrypt: Boolean = False; const IdentCrypt: Boolean = False; const Section: String = ''; const Ident: String = ''; const PathDelimiter: Char = PathDelim );
    destructor Destroy; override;

    procedure Reset;
    procedure Init( const Section: string = ''; const Ident: string = '' );
    property Filename: string read FFilename write SetFilename;

    property AutoFolder: boolean read FAutoFolder write FAutoFolder;
    property Password: string read FPassword write FPassword;
    property Passkey: integer read FPasskey write FPasskey;
    property Section: string read FSection write FSection;
    property Ident: string read FIdent write FIdent;
    property Crypt: boolean read FCrypt write FCrypt;
    property SectionCrypt: boolean read FSectionCrypt write FSectionCrypt;
    property IdentCrypt: boolean read FIdentCrypt write FIdentCrypt;
    property PathDelimiter: Char read FPathDelimiter write FPathDelimiter;

    function ReadString( const Ident: string = ''; const Default: String = '' ): String;
    function WriteString( const Ident: string = ''; const Value: String = '' ): Boolean;
  end;

passende aufrufe sehen dann so aus:

Delphi-Quellcode:

uses IniHelper;

...

var
  ini: TIniHelper;
begin
  ini := TIniHelper.Create(); // hier kann man alles mögliche initialisieren oder auch nichts, klappt alles hoffentlich ;-)

  ini := TIniHelper.Create( 'ininame.ext', True ); // so initialisiert man etwas was im AppData landet

// mit weiteren Werten der Create methode steuert man verschlüsselung
// hier ein komplexes Beispiel um standards nur einmal festlegen zu müssen
  ini := TIniHelper.Create( 'filename.ext', false, 'Mein AES Passwort', True, -967283, True, True, 'Setup' );


  if ini.WriteString('','x') = false then // schon hat man was in einer datei geschrieben... oder auch nicht, das zeigt diese auswertung
    Memo1.Lines.Add( 'Class write fail' )
    else
    Memo1.Lines.Add( 'Class write success' );

  ini.Filename := 'bla test\test.zwo'; // man kann jederzeit easy datei wechseln, mit oder ohne pfad

  ini.Init('was auch immer'); // so man kann jederzeit sein "root" wechseln oder beibehalten oder leer lassen :)

Viel Spass beim Testen wünscht KodeZwerg.

[KodeZwerg]

[reserviert]

[hoika]

Hallo,
hm, abgesehen von der AES-Verschlüsselung sehe ich hier sehe ich nichts Neues?
Und 128 ist zu wenig, ich würde 192 nehmen.

[EWeiss]

Zitat:

Zitat von hoika (Beitrag 1417419)

Hallo,
hm, abgesehen von der AES-Verschlüsselung sehe ich hier sehe ich nichts Neues?
Und 128 ist zu wenig, ich würde 192 nehmen.

Es wäre vielleicht nicht schlecht wenn er sich mal Emil's TIniFormater Klasse ansehen würde. :)

gruss

[p80286]

Zitat:

Zitat von EWeiss (Beitrag 1417423)

Zitat:

Zitat von hoika (Beitrag 1417419)

Hallo,
hm, abgesehen von der AES-Verschlüsselung sehe ich hier sehe ich nichts Neues?
Und 128 ist zu wenig, ich würde 192 nehmen.

Es wäre vielleicht nicht schlecht wenn er sich mal Emil's TIniFormater Klasse ansehen würde. :)

gruss

Ich würde das gerne. Aber sowohl die eingebaute Suchfunktion sowie mein favorisierter Suchanbieter finden nichts bei "TIniFormater".

Gruß
K-H

[KodeZwerg]

Wenn ich AES196 fertig habe sagt der nächste wieder zu wenig -> 256 usw.

Kannst Du echt einen AES128 verschlüsselten Inhalt wieder lesbar machen ohne Ahnung vom Passwort zu haben?

Zitat:

[qDRo1pi]
Ot9XOsjjPG=LZ1eOpbfCbHDIs5qIMH9MdetS7CsLtDiIa5ZApH tTN5pDdOtH6usHb9DL3TNDbLMQ6nfSq5NJL9fLdXYJaXZIsL2J s97ULTYHqvqHMqpGNXwCrPORK4zFG

Bin gespannt wie ein Flitzeboden wer das obige Lesbar machen kann. Es ist nur ein Text, kein Binärkrams.
Erstellt mit meiner IniHelper Klasse.

Emils TIniFormater finde auch ich nicht, häng das doch, wenn es zum Thema passt, hier mit ran?

[SProske]

Zitat:

Zitat von hoika (Beitrag 1417419)

Hallo,
hm, abgesehen von der AES-Verschlüsselung sehe ich hier sehe ich nichts Neues?
Und 128 ist zu wenig, ich würde 192 nehmen.

Gibt es irgendeine (seriöse) Quelle, die erklärt, wieso AES128 "zu wenig" wäre?

[DieDolly]

Seriös weiß ich nicht. Aber lesenswert. AES 128 reicht vollkommen aus.
https://www.eetimes.com/document.asp?doc_id=1279619

[Daniel]

Seriös ist wohl das BSI und deren jeweils aktuelle Fassung der technischen Richtlinien für die Schlüssellängen:

https://www.bsi.bund.de/SharedDocs/D...cationFile&v=8


Ja, AES128 gilt derzeit noch als sicher. Wobei natürlich die Frage zu stellen ist, warum die Wahl ausgerechnet auf AES128 fiel. Wenn man heute schon etwas Neues startet und auch noch Wincrypt nutzt, dann kann man gleich die heute stärkste Variante nutzen. Kostet nicht mehr und wenn Datensicherheit tatsächlich von Bedeutung ist, fällt der mangelnde WindowsXP-Support auch nicht ins Gewicht.

//edit: Der EETimes-Artikel ist sechs Jahre alt. Eine derart alte Aussage über Sicherheit und Unsicherheit von Algorithmen auf die Gegenwart übertragen zu wollen, kann ein fataler Fehler sein.

[EWeiss]

Zitat:

Ich würde das gerne. Aber sowohl die eingebaute Suchfunktion sowie mein favorisierter Suchanbieter finden nichts bei "TIniFormater".

[Ironie]Es war eine Anspielung auf "KodeZwergs TIniHelper Klasse"[/Ironie]

Abgesehen von der AES-Verschlüsselung (deine Worte) sehe ich auch keinen Sinn darin eine Klasse zu erstellen die im Grundfundament schon besteht.
Siehe TIniFile!
Warum das Rad neu erfinden ohne wirklich fundamental Neues.

Und wenn schon dann sollte so etwas wie eine Funktion zum Formatieren einer IniDatei schon Enthalten sein.
Es macht schon sinn alleine der Lesbarkeit halber nicht alles Untereinander zu klatschen, zwischen den Section sollte schon eine Leerzeile stehen.

Meine einfache Funktion.. Nein keine Klasse warum auch geht auch anders.

Delphi-Quellcode:

type
  PParseFile = ^TParseFile;
  TParseFile = record
    Nr: Integer;
    Str: string;
    Ptr: PParseFile;
    Max: Integer;
  end;
//....
var
  LineStart: PParseFile;
  FPBuffer: PParseFile;
  FToPBuffer: PParseFile;
  nReading: Integer;
//...

{$REGION 'procedure FormatINI'}
procedure FormatINI(Filename: string);
var
  sBuffer: string;
  ParseFile: TextFile;
  StringList: TStringList;
  StringParse: string;

procedure AppendToLinkedList(nReading: Integer; sBuffer: string);
begin

  New(FPBuffer);

  if nReading = 0 then
  Begin
    New(FToPBuffer);
    LineStart := FToPBuffer;
    LineStart^.Nr := 0;
  end;

  FPBuffer^.Nr := nReading;
  FPBuffer^.Str := sBuffer;
  LineStart^.Max := FPBuffer^.Nr;
  FToPBuffer^.Ptr := FPBuffer;
  FToPBuffer := FPBuffer;
end;

begin
  StringList := TStringList.Create;

  Assignfile(ParseFile, Filename);
  reset(ParseFile);

  try
    try
      while not eof(ParseFile) do
      begin
        ReadLN(ParseFile, sBuffer);
        AppendToLinkedList(nReading, sBuffer);
        inc(nReading);
      end;
    except
      raise Exception.Create(SysErrorMessage(GetLastError));
    end;
  finally
    nReading := 0;
    CloseFile(ParseFile);
  end;

  FPBuffer := LineStart;
  while (FPBuffer.Nr <= LineStart.Max - 1) do
  begin
    FPBuffer := FPBuffer.Ptr;
    StringParse := LeftTrim(FPBuffer.Str);
    if Length(StringParse) <> 0 then
      StringList.Add(FPBuffer^.Str);

    if FPBuffer.Nr > 0 then
      if LeftStr(FPBuffer^.Str, 1) = '[' then
        StringList.Insert(StringList.IndexOf(StringParse), '');
  end;

  StringList.SaveToFile(Filename);
  StringList.Free;

  Dispose(FPBuffer);
  FPBuffer := nil;
  LineStart := nil;

end;
{$ENDREGION}

Geht bestimmt schöner aber ist meine art.

Aufruf nachdem die INI erstellt wurde.

Delphi-Quellcode:

var
  ConfigIni: TIniFile;
//...
FormatINI(ConfigIni.FileName);

gruss

[KodeZwerg]

Öhm... also der Grundgedanke war nicht das Rad (IniFiles.pas) neu zu erfinden, nur die Handhabung stark zu simplifizieren.

Vielleicht einmal global definiert, ab da nurnoch mit den einfachen Befehlen zum lesen/schreiben aufrufen.
Ob nun mit oder ohne Crypt sei mal dahingestellt.

Wenn ich alle Typen in der Klasse aufgenommen habe kommt weitere funktionalität hinzu, wie die Ausnutzung der MemIniFile Klasse um mehrere Dinge abarbeiten zu können ohne dauernd öffnen/schließen zu müssen und zu guter letzt System-Registry einbindung.

Ich schaue mich mal auf Gammatesters Seite nach Crypt Alternativen um und wie da so die Lizensen sind.
Oder ich lasse es komplett raus und biete lediglich Schnittstellen an damit jeder das Einbinden kann was er hat oder eben nichts.

Großprojekte wie DEC oder DPCrypt als Voraussetzung zu stellen ist ja auch nicht jedermanns Sache.

Eine Formatierung der .ini Datei werde ich mit Sicherheit erstmal nicht berücksichtigen da es mir schlicht weg egal ist.
Aber netter Gedanke.

Da das Projekt anscheinend abgelehnt wird bleibt es wohl dabei. Danke für Feedback.

[mkinzler]

Zitat:

Großprojekte wie DEC oder DPCrypt als Voraussetzung zu stellen ist ja auch nicht jedermanns Sache.

Besser als externe Abhängigkeiten. Oder man verwendet die direkte Unterstützung des Betriebsystems.

[EdAdvokat]

Hallo KodeZwerg,
beim Kompilieren Deines Programms mit der AES 128-Verschlüsselung erhalte ich folgende Exception:

Zitat:

[dcc32 Fehler] Crypto.pas(44): E2250 Es gibt keine überladene Version von 'EncodeBytes', die man mit diesen Argumenten aufrufen kann
[dcc32 Fehler] Crypto.pas(56): E2010 Inkompatible Typen: 'System.TArray<System.Byte>' und 'TIdBytes'

Das tritt beim Aufruf der Function Base64_Encode auf:

Delphi-Quellcode:

function Base64_Encode(Value: TBytes): string;
var
  Encoder: TIdEncoderMIME;
begin
  Encoder := TIdEncoderMIME.Create(nil);
  try
    Result := Encoder.EncodeBytes(Value);
  finally
    Encoder.Free;
  end;
end;

mache ich da was falsch oder wie hängt das zusammen.
Dein vorheriges Programm mit der xor-Verschlüsselung läuft gut durch.

[Uwe Raabe]

System.NetEncoding.pas kann das auch mit TBytes:

Delphi-Quellcode:

function Base64_Encode(Value: TBytes): string;
begin
  Result := TNetEncoding.Base64.EncodeBytesToString(Value);
end;

[DieDolly]

Wenn ich mich nicht irre sind die TId's wesentlich schneller. Ich mache immer einen großen Bogen um die Delphi-eigenen Funktionen, da die einfach zu langsam sind.

[EdAdvokat]

habe nun den Rat von Uwe Raabe befolgt und einfach in den
Proceduren read und write

Delphi-Quellcode:

 ...if WriteIniCryptString( 'Testfile.cfg', 'Setup', 'CryptStringEntry', 'This is a Crypted String.', '-967283')  then
      begin
        Memo1.Lines.Add( 'CryptStringEntry Saved.' )
      end...

den Wert -967283 in Hochkomma gesetzt.
Hoffentlich war das exakt, doch so klappt es, denn eine Inkompatibilität von String und Integer wurde angemahnt.
Da writeIniCryptString strings verlangt, glaube ich somit richtig zu liegen.

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1418308)

Wenn ich mich nicht irre sind die TId's wesentlich schneller. Ich mache immer einen großen Bogen um die Delphi-eigenen Funktionen, da die einfach zu langsam sind.

1. Kannst du das irgendwie belegen oder ist das nur ein Vorurteil?
2. Ist schneller in diesem Kontext (IniFiles) wirklich relevant?
3. Finde ich den Aufruf von TNetEncoding wesentlich eleganter.
4. Was, wenn die Indys nun mal keine TBytes akzeptieren?
5. Will ich wirklich eine zusätzliche Abhängigkeit zu den Indy Packages (wenn ich z.B. mit Packages compiliere)?

[Alter Mann]

Frage am Rande:

Wo bitte wird TIniHelper aufgerufen/verwendet?

[Uwe Raabe]

Zitat:

Zitat von DieDolly (Beitrag 1418308)

Wenn ich mich nicht irre sind die TId's wesentlich schneller. Ich mache immer einen großen Bogen um die Delphi-eigenen Funktionen, da die einfach zu langsam sind.

Kurzer Performancetest beweist übrigens das Gegenteil. Die Delphi Implementierung ist sogar noch geringfügig schneller. Dabei habe ich die notwendige TBytes -> TIdBytes Konvertierung sogar noch nicht mal berücksichtigt.

[EdAdvokat]

Zitat:

Zitat von Alter Mann (Beitrag 1418326)

Frage am Rande:

Wo bitte wird TIniHelper aufgerufen/verwendet?

ich denke mal in der unit iniHelper wird IniHelper deklariert und erhält seine Felder und Methoden
und in der unit1 wird mit IniHelper gewerkelt.

[DieDolly]

Zitat:

Kannst du das irgendwie belegen oder ist das nur ein Vorurteil?

Kann ich belegen. Habe selber viele Tests gemacht und bin danach von den Delphi-Units weg.

[Uwe Raabe]

Delphi-Quellcode:

program Project445;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.SysUtils,
  System.NetEncoding,
  System.Diagnostics,
  IdCoderMIME,
  IdGlobal;

var
  Value: TBytes = nil;
  Indies: TIdBytes = nil;

function Net: string;
begin
  Result := TNetEncoding.Base64.EncodeBytesToString(Value);
end;

function Indy: string;
var
  Encoder: TIdEncoderMIME;
begin
  Encoder := TIdEncoderMIME.Create(nil);
  try
    Result := Encoder.EncodeBytes(Indies);
  finally
    Encoder.Free;
  end;
end;

procedure InitValue;
var
  I: Integer;
begin
  SetLength(Value, 10*1024);
  SetLength(Indies, 10*1024);
  for I := 0 to Length(Value) - 1 do begin
    Value[I] := Random(256);
    Indies[I] := Value[I];
  end;
end;

var
  sw: TStopWatch;
  I: Integer;
begin
  try
    InitValue;
    sw := TStopWatch.StartNew;
    for I := 1 to 100000 do
      Net;
    Writeln(sw.ElapsedMilliseconds);
    sw := TStopWatch.StartNew;
    for I := 1 to 100000 do
      Indy;
    Writeln(sw.ElapsedMilliseconds);
  except
    on E: Exception do
      Writeln(E.ClassName, ': ', E.Message);
  end;
  Readln;
end.

[EWeiss]

Zitat:

Kann ich belegen. Habe selber viele Tests gemacht und bin danach von den Delphi-Units weg.

Zeige doch mal ein Beispiel wie das von Uwe so das man das vergleichen kann.
Das wäre innovativ.

gruss

[DieDolly]

Den Code habe ich schon seit Monaten nicht mehr. Und den jetzt extra wieder in das eine Projekt einbauen ist mir zu nervig.

[Alter Mann]

@EdAdvokat

Zitat:

ch denke mal in der unit iniHelper wird IniHelper deklariert und erhält seine Felder und Methoden
und in der unit1 wird mit IniHelper gewerkelt.

Ok, dann muss ich mal zum Optiker. Ich find da nichts was dies rechtfertigt.

[KodeZwerg]

Es tut mir leid das ich das vor mir hingeschoben habe.

In Post #1 ist ein Anwendungsbeispiel abgebildet wie ich es mir erhofft habe zu nutzen.

Da ja jetzt anscheinend doch irgendwie Interesse besteht, werde ich die Unit komplettieren.


Wenn mein Beispiel in #1 unverständlich sein sollte, bitte sagt mir Bescheid wie ich es gescheiter ausdrücken könnte.
Oder ich häng da mal eine Demo-Anwendung mit ran mit der ich das hier erbastelt habe.

Warum Base64 bei manchen eine AV auslöst kann ich momentan nicht beurteilen da bei mir mit D2010 und Tokyo beides schnurrt.

Ich rate dringend davon ab die einzelnen methoden aufzurufen, ich habe die nur drinnen gelassen weil es ein schnappschuss von meiner arbeit ist die ich noch in die Klasse prügeln möchte, poe á poe.


Herzliche Grüße.

[Schokohase]

@Uwe

sieht aus, als ob die Indy Variante tatsächlich schneller ist - wenigstens bei mir

Code:

xxxxx|Win32|Win64|
-----+-----+-----+
Net   | 8652| 3427|
Indy | 2859| 3073|

[Uwe Raabe]

Zitat:

Zitat von Schokohase (Beitrag 1418348)

@Uwe

sieht aus, als ob die Indy Variante tatsächlich schneller ist - wenigstens bei mir

Code:

xxxxx|Win32|Win64|
-----+-----+-----+
Net   | 8652| 3427|
Indy | 2859| 3073|

Also hier bekomme ich folgende Werte unter Delphi 10.2 Tokyo (Release ohne Debugger)

Code:

xxxxx|Win32|Win64|
-----+-----+-----+
Net   | 2768| 3614|
Indy | 2959| 3136|

"wesentlich schneller" sieht anders aus (vielleicht so ab Faktor 2-3).

[DieDolly]

Vergleicht das mal mit diesen Units. Mit denen wird es schneller
http://www.wolfgang-ehrhardt.de/crchash_en.html

[Daniel]

Wozu? Im Kontext dieser INI-Klasse wären jegliche Geschwindigkeits-Unteschiede nicht messbar. Da nimmt man doch lieber die Bordmittel.