OSDev.org

Code: Select all

type
 TCapability = packed record
  lwObjectID: longword;
  wRights: word;
  {This means the check value is a longword.}
  CheckValue: array [0..9] of byte;
 end;
 PCapability = ^TCapability;

procedure MakeCapability(var Cap: TCapability; lwCheckValue: longword);
function CheckCapability(Cap: TCapability; lwCheckValue: longword): Boolean;

function GetObjectID(): longword;

Code: Select all

 capability_check(cap) {
   return cap.signature == md5(cap, too_many_secrets[cap.server_id]);
}

Code: Select all

var
 lwNextObjectID: longword;

procedure MakeCapability(var Cap: TCapability; lwCheckValue: longword);
var
i,j: longword;
begin
Move(Cap.lwObjectID,Cap.CheckValue[0],sizeof(longword) + sizeof(word));
Move(lwCheckValue,Cap.CheckValue[6],sizeof(longword));
{This encryption sucks, but use it for starters.}
j:= 0;
for i:= 0 to 10 - 1 do
 begin
 Cap.CheckValue[i]:= Cap.CheckValue[i] + not PByte(@lwCheckValue)[j];
 j:= j + 1;
 if j = sizeof(longword) - 1 then
  j:= 0;
 end;
end;

function CheckCapability(Cap: TCapability; lwCheckValue: longword): Boolean;
var
i,j: longword;
begin
CheckCapability:= false;
j:= 0;
for i:= 0 to 10 - 1 do
 begin
 Cap.CheckValue[i]:= Cap.CheckValue[i] - not PByte(@lwCheckValue)[j];
 j:= j + 1;
 if j = sizeof(longword) - 1 then
  j:= 0;
 end;
if (PLongword(@Cap.CheckValue[0])^ = Cap.lwObjectID) and
   (PWord(@Cap.CheckValue[4])^ = Cap.wRights) and
   (PLongword(@Cap.CheckValue[6])^ = lwCheckValue) then
 CheckCapability:= true;
end;

function GetObjectID(): longword;
begin
GetObjectID:= lwNextObjectID;
lwNextObjectID:= lwNextObjectID + 1;
end;

Code: Select all

capability_check[0] == oid[0] + secret_0

Code: Select all

void MakeCapability(TCapability* Cap,unsigned long ulCheckValue)
{
/* This will copy ulObjectID and usRights into the signature. */
memcpy(&Cap->Signature[0],&Cap->ulObjectID,sizeof(unsigned long) + sizeof(word));
memcpy(&Cap->Signature[6],&ulCheckValue,sizeof(unsigned long));
for(int i=0;i<10;i++)
 Cap->Signature[i] = Cap->Signature[i] + ~((unsigned char*)&ulCheckValue)[i % (sizeof(unsigned long)*sizeof(unsigned long)) / sizeof(unsigned long)] ^ ((unsigned char*)&ulCheckValue)[i % sizeof(unsigned long)];
}

int CheckCapability(TCapability Cap,unsigned long ulCheckValue)
{
CheckCapability = 0;
for(i=0;i<10;i++)
 Cap.Signature[i] = (Cap.Signature[i] ^ ((unsigned char*)&ulCheckValue)[i % sizeof(unsigned long)]) - ~((unsigned char*)&ulCheckValue)[i % ((sizeof(unsigned long)*sizeof(unsigned long)) / sizeof(unsigned long)];
if( (*((unsigned long*)&Cap.Signature[0]) == Cap.ulObjectID) &&
    (*((unsigned short*)&Cap.Signature[4]) == Cap.wRights) &&
    (*((unsigned long*)&Cap.Signature[6]) == ulCheckValue) )
 CheckCapability = 1;
}

Code: Select all

struct stuff_to_sign {
    capability_t cap;
    char secret[512/8 - sizeof(capability_t)];
} sign_this;

init() {
    create_some_secret(&sign_this.secret, sizeof(sign_this.secret));
}

makeCapability(...) {
    sign_this.cap=*cap;
    cap->signature=md5hash(&sign_this,sizeof(sign_this));   
}

checkCapability(...) {
    sign_this.cap=*cap;
    sign_this.cap.signature=empty_signature;
    return md5hash(&sign_this,sizeof(sign_this)) == cap->signature;
}

Code: Select all

type
 TCapability = packed record
  lwContextID: longword;
  wObjectID,wObjectRights: word;       {This means the signature key is 128 bits long.}
  Signature: array [0..23] of byte;
 end;
 PCapability = ^TCapability;

TInterfaceRights = (irLink = 0,irMigrate = 1);
 TContextRights = (crImport = 0,crPermit = 1,crMatch = 2,crLink = 4,crMatch = 8);

{
    Whatever one of these points to is only ever linked to by the kernel. Finds out what rights the prolary will give right now.  If szInterface is nil it asks about the context itself.
}
 TUnknownInterface = packed record
  Permit: function(szInterface: PChar): TCapability;
  {Given the current state of the thread, get the key the context wants to use for this object.} 
  Key: procedure(wObjectID: word; var Key: array [0..3] of longword);
 end;

{
   Asks the kernel for a capability to import a certain interface.
   If nil is passed for szInterface it asks a context what rights another context has to load it at all.
}
function Permit(szInterface: PChar; cidContext: longword): TCapability;

{
  Returns whether the given interface definition matches the one the context exports.
}
function Match(icContext: TCapability; szInterfaceDefinition: PChar): integer;

{ 
  Obtains an interface table for an interface if the capability has linking rights.
}
function Link(icInterface: TCapability; pLinkTable: PPointer; lwTableEntries: longword): integer;

{
   Loads a context into virtual address space based on a capability.
}
function Import(icContext: TCapability): integer;

{
   Finds a context id based on a context name or an interface it supports.
}
function FindContext(szContext: PChar; bInterface: Boolean): integer;

{
  If a special capability with superuser rights is passed in the other capability is automatically made valid by its authority.
}
function Super(cSuper: TCapability; var Capability: TCapability): integer;