Log - File in eingeschränkten User-Account verstecken?!

[nsamaster]

Hallo!

Ich suche möglichkeiten, wie ich eine Log-File (reiner Text) in einem User-Account unter XP verstecken kann, ohne das diese der Benutzer finden kann, bzw. löschen oder sonst wie manipulieren kann.

Besteht vielleicht die Möglichkeit mein Programm irgendwie dazu zu bewegen, die Log-File in ein Verzeichnis des Admin's zu schreiben?

[SirThornberry]

wenn dein Programm unter den Rechten des Nutzers läuft kann dein Programm auch nur dort hinn wo der Benutzer hinn kann und umgekehrt. Eine Möglichkeit wäre einen Dienst laufen zu lassen der Daten entgegen nimmt (von jedem Nutzer) und diese dann an einem Ort speichert wo nicht jeder Zugriff hat.

[nsamaster]

OK, hast du für mich ein paar Links wie ich einen Dienst in Delphi programmieren kann? Hatte schonmal gegoogelt, aber nicht das richtige gefunden...

[nsamaster]

Ok, das mit den Links hat sich erledigt, habe gerade die Board - interne Suche gefunden ;-)

[Luckie]

Warum muss denn die Logdatei versteckt sein?

[Dezipaitor]

Zitat:

Zitat von nsamaster

Ok, das mit den Links hat sich erledigt, habe gerade die Board - interne Suche gefunden ;-)

Willst du nicht andere an deiner Lösung teilhaben lassen? So ist dieser Thread nichts wert.

[nsamaster]

??? Habe noch keine Lösung gefunden, lediglich einige Links aus diesem Forum zum Thema Dienste, aber bitte:

http://www.delphipraxis.net/internal...ct.php?t=73540

Die Log-Datei möchte ich vor manipulation schützen. Darüber wird protokolliert, wann der Benutzer wieviel Seiten gedruckt hat.

[Dezipaitor]

Also vor Veränderung etwas zu schützen ist so gut wie unmöglich ohne TPM.
Du kannst natürlich Binärdaten schreiben und die Daten verschlüsseln. Was auch geht ist den Zugriff auf die Datei über ACLs zu unterbinden. Aber jeder mit Adminrechten kann sich Zugang verschaffen.

[Phoenix]

Du hast leider Deine Delphi-Version nicht angegeben.

Meine Idee wäre, Du machst eine kleine lokale Datenbank (Interbase oder Firebird oder Blackfish). Diese lässt Du als Dienst laufen und richtest auf dieser Datenbank eine Log-Tabelle ein und einen Datenbankbenutzer, der auf diese Tabelle nur Insert- und Select-Rechte hat, aber keine Update und keine Delete-Rechte. Damit kann in der Tabelle nach dem Logeintrag nichts mehr manipuliert, aber jederzeit ausgelesen werden.

[mjustin]

Zitat:

Zitat von Phoenix

Du hast leider Deine Delphi-Version nicht angegeben.

Meine Idee wäre, Du machst eine kleine lokale Datenbank (Interbase oder Firebird oder Blackfish). Diese lässt Du als Dienst laufen und richtest auf dieser Datenbank eine Log-Tabelle ein und einen Datenbankbenutzer, der auf diese Tabelle nur Insert- und Select-Rechte hat, aber keine Update und keine Delete-Rechte. Damit kann in der Tabelle nach dem Logeintrag nichts mehr manipuliert, aber jederzeit ausgelesen werden.

Ich dachte bisher immer, dass eine Firebird/Interbase Datenbank schon kompromittiert ist, sobald man physisch Zugang zum Rechner hat. (Man kann die Admin-Datenbank mit Benutzerrechten z.B. ersetzen)

[QuickAndDirty]

Ich würde es einfach in die Ereignisanzeige schreiben.
Da guckt nie einer Rein.

Die Funktion dazu heist Eventlog.

Hier ist eine Unit aus google Groups die das macht.
Ich habe leider den Autor nicht im Kopf oder notiert.

Delphi-Quellcode:

unit EventLog; //habe die unit aus google.

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms,
Dialogs;

type
  TEventLogRecord = record
    SourceName: AnsiString;
    ComputerName: AnsiString;
    Account: AnsiString;
    Domain: AnsiString;
    TimeGenerated: TDateTime;
    TimeWritten: TDateTime;
    EventID: DWORD;
    EventType: WORD;
    Catagory: WORD;
    Strings: array of AnsiString;
  end;

  TEventLog = class(TComponent)
  private
    { Private declarations }
    m_hEventLog: THandle;
  protected
    { Protected declarations }
    function UCTToDateTime(DateTime: DWORD): TDateTime;
  public
    { Public declarations }
    constructor Create(AOwner: TComponent); override;
    destructor Destroy; override;

    procedure Open(SourceName, UNCServerName: AnsiString); overload;
    procedure Open(SourceName: AnsiString); overload;
    procedure Close;

    // EVENTLOG_ERROR_TYPE, EVENTLOG_WARNING_TYPE,
    // EVENTLOG_INFORMATION_TYPE, EVENTLOG_AUDIT_SUCCESS,
    // EVENTLOG_AUDIT_FAILURE

    procedure Report(AType: WORD; Strings: TStringList; dwEventID: DWORD = 0;
                     ACatagory: WORD = 0; lpRawData: Pointer = nil;
                     dwDataSize:DWORD = 0); overload;
    procedure Report(AType: WORD; Strings: AnsiString; dwEventID: DWORD = 0;
                     ACatagory: WORD = 0; lpRawData: Pointer = nil;
                     dwDataSize: DWORD = 0); overload;
    procedure Clear; overload;
    procedure Clear(FileName: TFileName); overload;
    procedure Backup(FileName: TFileName);
    function Read(Index: Integer): TEventLogRecord;
    function Count: DWORD;
  published
    { Published declarations }
  end;

var
StandardEventLog:TEventLog;

Const
  EVENTLOG_SUCCESS          = $0000;  // habe ich aus der Unit Windows kopiert
  EVENTLOG_ERROR_TYPE       = $0001;
  EVENTLOG_WARNING_TYPE     = $0002;
  EVENTLOG_INFORMATION_TYPE = $0004;
  EVENTLOG_AUDIT_SUCCESS    = $0008;
  EVENTLOG_AUDIT_FAILURE    = $0010;
  
implementation


const
  EVENTLOG_SEEK_READ       = 4;
  EVENTLOG_BACKWARDS_READ  = 2;
  EVENTLOG_FORWARDS_READ   = 2;
  EVENTLOG_SEQUENTIAL_READ = 0;

//------------------------------------------------------------------------------
constructor TEventLog.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  m_hEventLog:= INVALID_HANDLE_VALUE;
end;
//------------------------------------------------------------------------------
destructor TEventLog.Destroy;
begin
  Close();
  inherited Destroy();
end;
//------------------------------------------------------------------------------
procedure TEventLog.Open(SourceName: AnsiString);
begin
  Self.Open(SourceName, '');
end;
//------------------------------------------------------------------------------
procedure TEventLog.Open(SourceName, UNCServerName: AnsiString);
var lpUNCServerName, lpSourceName: array[0..MAX_PATH] of char;
    AHandle: THandle;
begin
  if (m_hEventLog = INVALID_HANDLE_VALUE) then
  begin
    StrPCopy(lpUNCServerName, UNCServerName);
    StrPCopy(lpSourceName, SourceName);
    AHandle:= OpenEventLog(lpUNCServerName, lpSourceName);
    if (AHandle = 0) then
      raise Exception.Create(SysErrorMessage(GetLastError()));

    m_hEventLog:= AHandle;
  end;
end;
//------------------------------------------------------------------------------
procedure TEventLog.Close;
begin
  if (m_hEventLog <> INVALID_HANDLE_VALUE) then
  begin
    if (not CloseEventLog(m_hEventLog)) then
      raise Exception.Create(SysErrorMessage(GetLastError()));

    m_hEventLog:= INVALID_HANDLE_VALUE;
  end;
end;
//------------------------------------------------------------------------------
procedure TEventLog.Report(AType: WORD; Strings: TStringList;
dwEventID: DWORD = 0; ACatagory: WORD = 0; lpRawData: Pointer = nil;
dwDataSize: DWORD = 0);
var lpStrings: array of PChar;
    Result: Boolean;
    I: Integer;
begin
  SetLength(lpStrings, Strings.Count);
  for I:=0 to Strings.Count -1 do
  begin
    GetMem(lpStrings[I], Length(Strings[I]) +1);
    StrPCopy(lpStrings[I], Strings[I]);
  end;

  Result:= ReportEvent(m_hEventLog, AType, ACatagory, dwEventID, nil,
Strings.Count, dwDataSize, lpStrings, lpRawData);

  for I:=0 to Strings.Count -1 do
    FreeMem(lpStrings[I]);

  if (not Result) then
    raise Exception.Create(SysErrorMessage(GetLastError()));
end;
//------------------------------------------------------------------------------
procedure TEventLog.Report(AType: WORD; Strings: AnsiString; dwEventID:
DWORD = 0; ACatagory: WORD = 0; lpRawData: Pointer = nil; dwDataSize:
DWORD = 0);
var StringList: TStringList;
begin
  StringList:= TStringList.Create();
  try
    StringList.Add(Strings);
    Self.Report(AType, StringList, dwEventID, ACatagory, lpRawData,
dwDataSize);
  finally
    StringList.Free();
  end;
end;
//------------------------------------------------------------------------------
procedure TEventLog.Clear;
begin
  Self.Clear('');
end;
//------------------------------------------------------------------------------
procedure TEventLog.Clear(FileName: TFileName);
var lpFileName: PChar;
begin
  // if we need to backup the eventlog then copy the filename to a LPSTR
  lpFileName:= nil;

  if (Length(FileName) > 0) then
  begin
    GetMem(lpFileName, Length(FileName) +1);
    StrPCopy(lpFileName, FileName);
  end;

  try
    if (not ClearEventLog(m_hEventLog, lpFileName)) then
      raise Exception.Create(SysErrorMessage(GetLastError()));
  finally
    // free the memory
    FreeMem(lpFileName);
  end;
end;
//------------------------------------------------------------------------------
procedure TEventLog.Backup(FileName: TFileName);
var lpFileName: array[0..MAX_PATH] of char;
begin
  StrPCopy(lpFileName, FileName);

  // backup the current event log
  if (not BackupEventLog(m_hEventLog, lpFileName)) then
    raise Exception.Create(SysErrorMessage(GetLastError()));
end;
//------------------------------------------------------------------------------
function TEventLog.Read(Index: Integer): TEventLogRecord;
type
  PEVENTLOGRECORD = ^EVENTLOGRECORD;
  EVENTLOGRECORD = packed record
    Length: DWORD;
    Reserved: DWORD;
    RecordNumber: DWORD;
    TimeGenerated: DWORD;
    TimeWritted: DWORD;
    EventID: DWORD;
    EventType: WORD;
    NumStrings: WORD;
    EventCatagory: WORD;
    ReservedFlags: WORD;
    ClosingRecordNumber: DWORD;
    StringOffset: DWORD;
    UserSidLength: DWORD;
    UserSidOffset: DWORD;
    DataLength: DWORD;
    DataOffset: DWORD;
  end;

var lpEventLogRecord: PEVENTLOGRECORD;
    I, Offset, BufferSize, NumberOfBytesRead, NumberOfBytesNeeded:
Cardinal;
    lpStrings: PChar;
    lpSID: PSID;
    szAccount, szDomain: array[0..MAX_PATH] of Char;
    dwAccountSize, dwDomainSize: DWORD;
    peUse: Cardinal;
begin
  BufferSize:= SizeOf(EVENTLOGRECORD) + 8192;
  GetMem(lpEventLogRecord, BufferSize);

  try
    NumberOfBytesRead:= 0;
    NumberOfBytesNeeded:= 0;
    if (ReadEventLog(m_hEventLog, EVENTLOG_SEEK_READ or
        EVENTLOG_BACKWARDS_READ or EVENTLOG_FORWARDS_READ,
        Index +1, lpEventLogRecord, BufferSize, NumberOfBytesRead,
        NumberOfBytesNeeded)) then
    begin

      Offset:= SizeOf(EVENTLOGRECORD);
      Result.SourceName:= StrPas(@PChar(lpEventLogRecord)[Offset]);

      Inc(Offset, 1 + StrLen(@PChar(lpEventLogRecord)[Offset]));
      Result.ComputerName:= StrPas(@PChar(lpEventLogRecord)[Offset]);

      Result.TimeGenerated:= UCTToDateTime(lpEventLogRecord^.TimeGenerated);
      Result.TimeWritten:= UCTToDateTime(lpEventLogRecord^.TimeWritted);
      Result.EventID:= lpEventLogRecord^.EventID;
      Result.EventType:= lpEventLogRecord^.EventType;
      Result.Catagory:= lpEventLogRecord^.EventCatagory;

      SetLength(Result.Strings, lpEventLogRecord^.NumStrings);
      Offset:= lpEventLogRecord.StringOffset;
      if lpEventLogRecord^.NumStrings > 0 then
      begin
        for I:=0 to lpEventLogRecord^.NumStrings -1 do
        begin
          lpStrings:= @PChar(lpEventLogRecord)[Offset];
          Result.Strings[I]:= StrPas(lpStrings);
          Inc(Offset, 1 + StrLen(lpStrings));
        end;
      end;

      // get account information
      Offset:= lpEventLogRecord^.UserSidOffset;
      lpSID:= @(PChar(lpEventLogRecord)[Offset]);
      if (lpEventLogRecord^.UserSidLength > 0) then
      begin
        dwAccountSize:= MAX_PATH;
        dwDomainSize:= MAX_PATH;
        if (not LookupAccountSid(nil, lpSID, szAccount, dwAccountSize,
                                 szDomain, dwDomainSize, peUse)) then
          raise Exception.Create(SysErrorMessage(GetLastError()));

        Result.Domain:= StrPas(szDomain);
        Result.Account:= StrPas(szAccount);
      end;
    end else
      raise Exception.Create(SysErrorMessage(GetLastError()));
  finally
    FreeMem(lpEventLogRecord);
  end;
end;
//------------------------------------------------------------------------------
function TEventLog.Count: DWORD;
begin
  if (not GetNumberOfEventLogRecords(m_hEventLog, Result)) then
    raise Exception.Create(SysErrorMessage(GetLastError()));
end;
//------------------------------------------------------------------------------
function TEventLog.UCTToDateTime(DateTime: DWORD): TDateTime;
var Hour, Min, Sec: WORD;
    NumberOfDays: DWORD;
begin
  //
  // UTC: This time is measured in the number of seconds elapsed
  //      since 00:00:00 January 1, 1970, Universal Coordinated Time.
  //

  NumberOfDays:= DateTime div (60*60*24);

  DateTime:= DateTime mod (60*60*24);
  Hour:= 1 + DateTime div (60*60);
  DateTime:= DateTime mod (60*60);
  Min:= DateTime div 60;
  DateTime:= DateTime mod (60);
  Sec:= DateTime;
  Result:= EncodeDate(1970, 1, 1) + NumberOfDays + EncodeTime(Hour,
Min, Sec, 0);
end;
//------------------------------------------------------------------------------

end.

Evtl. kannst du den Inhalt der Logs auch Base64 "verschlüsseln"... nur für den Fall das einer mal reinguckt.

[Luckie]

Zitat:

Zitat von QuickAndDirty

Ich würde es einfach in die Ereignisanzeige schreiben.
Da guckt nie einer Rein.

Also ich gucke da regelmäßig rein. Aber davon mal abgesehen, sollten da nur Systemereignisse rein und nicht ganze Logs. Weil wenn man dann nämlich mal einen Fehler sucht und man die wichtigen Einträge vor lauter Logeinträgen von zich Programmen nicht mehr sieht, ist das nicht sehr schön. Aber wenn es unbedingt das Ereignislog sein muss, dann bitte in einen eigenen Abschnitt. Ich hab auf meiner Seite auch noch mal eine Anleitung, wie man in die Ereignisanzeige schreibt: http://www.michael-puff.de/Artikel/ReportEvent.shtml

[Phoenix]

Zitat:

Zitat von mjustin

Ich dachte bisher immer, dass eine Firebird/Interbase Datenbank schon kompromittiert ist, sobald man physisch Zugang zum Rechner hat. (Man kann die Admin-Datenbank mit Benutzerrechten z.B. ersetzen)

Generell kann man sagen: Wenn jemand anderes physischen Zugriff auf Dein System hat, ist es nicht mehr Dein System. Da ist es vollkommen egal, wohin Du Dein Log schreibst, jemand der die Kiste z.B. mit einem Fremdsystem von CD booten kann, kann Dir jedes Log aushebeln. Egal ob es in einer Datenbank steckt oder nicht.

Wobei ich davon ausgehe, dass fremde Bootquellen im Bios deaktiviert sind, kein Nicht-Admin das Bios-Passwort kennt und auch niemand am Rechner rumschraubt, nur um ein Log auszuhebeln das lediglich anzeigt wieviel er gedruckt hat.

Sofern so sichergestellt ist, dass der Benutzer seine Rechte nicht erweitern kann (also von seinem normalen User-Account irgendwie an Admin-Rechte kommt), kann er auch nicht an der Datenbank rumfummeln.

[mkinzler]

Oder man verwendet ein verschlüsseltes Dateisystem oder Platte

[QuickAndDirty]

Sollte das Problem sein das ein User die Arbeit sabotiert und einfach den Netzwerkdrucker leer druckt,
und das eurem Programm zur last gelegt wird, dann lässt sich das sicher mit irgendwie anders verfolgen.

Man kann das Log evtl. auch in den CurrentUser Bereich der Registry schreiben ?
Oder bedarf es auch dafür rechte?
Generell wäre es auch net wenn das Log einfach verschlüsselt ist.
So kann niemand was dran ändern ohne es zu zerstören und dann wüste man das es jemand gibt der Sabotiert.

Dann kann man ein Log auch per IEComponente raus schmuggeln...und es auf einem Webserver speichern.