[fpc-pascal] Processing passwords etc.

[Michael Van Canneyt]

On Sat, 12 Apr 2014, Sven Barth wrote:

> 
> Am 11.04.2014 20:50 schrieb "waldo kitty" <wkitty42 at windstream.net>:
> >
> > On 4/11/2014 5:03 AM, Michael Van Canneyt wrote:
> >>
> >> The main point is that in FPC you can install a memory manager that wipes out
> >> any memory when getting or releasing it, if you want to make your software more
> >> secure that way.
> >
> [snip]
> >
> > i don't know how one would go about cleaning released memory as someone else asked about (eg: extending an array or string
> or etc)... once the memory is released, it is no longer accessible, right?
> 
> That's where the heap manager comes in. In FPC every allocation that is not done manually through OS functions (namely
> string/array allocation, class allocation, getmem() and new()) go through the heap manager of which you can register a
> custom one. This heap manager hooks the allocation and deallocation calls and thus you could provide a manager that clears
> deallocated memory (or fills with random data) before it's passed on to the default heap manager.

Attached is an implementation that allows you to specify:

What to do when allocating memory (zero out, randomize, nothing)
What to do when freeing memory (zero out, randomize, nothing).

Careful, it does not play well with the heaptrc unit.

If there is an interest in such thing, we can add it to the RTL.

Michael.
-------------- next part --------------
{
    This file is part of the Free Pascal run time library.
    Copyright (c) 1999-2000 by the Free Pascal development team

    "Safe" Heap manager interface section

    See the file COPYING.FPC, included in this distribution,
    for details about the copyright.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

 **********************************************************************}
unit safemmgr;

interface

Type
  TMemAction = (
    maZero,   // Zero out the memory
    maRandom, // Fill with Random data
    maNone    // Do nothing
  );
  
Var
  // Can be set at any time.
  GetAction : TMemAction = maZero;
  FreeAction : TMemAction = maZero;

// You can set/unset the memory manager at any time, but it is set during intialization.
Procedure InitSafeMemManager;
Procedure DoneSafeMemManager;

Implementation

Var
  M : TMemoryManager;

Procedure ZeroMem(Mem : PByte; ASize : ptruint);

begin
  if (Asize=0) then exit;
  FillWord(Mem^,ASize div 2,0);
  if (ASize mod 2)=1 then
    Mem[ASize-1]:=0;
end;

Procedure RandomMem(Mem : PByte; ASize : ptruint);

Var
  I : ptruint;
  PW : PWord;

begin
  if (Asize=0) then exit;
  PW:=PWord(Mem);
  For I:=0 to (ASize div 2) do
    PW[I]:=Random($FFFF);
  if (ASize mod 2)=1 then
    Mem[ASize-1]:=Random($FF);
end;

Function SafeGetmem (Size:ptruint):Pointer;

begin
  Result:=M.Getmem(Size);
  Case GetAction of
    maZero : ZeroMem(Result,Size);
    maRandom : RandomMem(Result,Size);
  end;
end;

Function SafeFreeMemSize(p:pointer;Size:ptruint):ptruint;

begin
  Case FreeAction of
    maZero : ZeroMem(P,Size);
    maRandom : RandomMem(P,Size);
  end;
  Result:=M.FreeMemSize(P,Size);
end;

Function SafeFreeMem (p:pointer):ptruint;

begin
  Result:=SafeFreeMemSize(P,M.MemSize(P));
end;


Function SafeAllocMem (Size:ptruint):Pointer;

begin
  Result:=M.AllocMem(Size);
  Case GetAction of
    maZero : ZeroMem(Result,Size);
    maRandom : RandomMem(Result,Size);
  end;
end;

Function SafeReAllocMem(var p:pointer;Size:ptruint):Pointer;

Var
  OP : PByte;
  GOS,FOS : ptruint;

begin
  OP:=P;
  FOS:=M.MemSize(P);
  GOS:=FOS;
  Result:=M.ReAllocMem(P,Size);
  If (P<>OP) then
    P:=OP
  else
    if (FOS>Size) then
      begin
      Inc(OP,FOS);
      Dec(FOS,Size);
      end;
  if (OP<>Nil) and (FOS>0) then
    Case FreeAction of
      maZero : ZeroMem(OP,FOS);
      maRandom : RandomMem(OP,FOS);
    end;
  if (GOS<Size) then
    begin
    OP:=Result;
    Inc(OP,GOS);
    Dec(GOS,Size);
    Case GetAction of
      maZero : ZeroMem(OP,GOS);
      maRandom : RandomMem(OP,GOS);
    end;
    end;
end;

Function SafeMMinstalled : Boolean;

Var
  CM : TMemoryManager;

begin
  FillChar(CM,SizeOf(TMemoryManager),#0);
  GetMemoryManager(CM);
  Result:=Pointer(CM.AllocMem)=Pointer(@SafeAllocMem);
end;

Procedure InitSafeMemManager;

Var
  NM : TMemoryManager;

begin
  If SafeMMInstalled then
     exit;
  GetMemoryManager(M);
  NM:=M;
  NM.FreeMem:=@SafeFreeMem;
  NM.FreeMemSize:=@SafeFreeMemSize;
  NM.GetMem:=@SafeGetMem;
  NM.AllocMem:=@SafeAllocMem;
  NM.ReAllocMem:=@SafeReAllocMem;
  SetMemoryManager(NM);
end;

Procedure DoneSafeMemManager;


begin
  If Not SafeMMInstalled then
     exit;
  SetMemoryManager(M);
end;

initialization
  InitSafeMemManager;
finalization
  DoneSafeMemManager;
end.