241 lines
10 KiB
Java
241 lines
10 KiB
Java
/*
|
|
Copyright 2019-2022 Dmitry Isaenko
|
|
|
|
This file is part of libKonogonka.
|
|
|
|
libKonogonka is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
libKonogonka 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. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with libKonogonka. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
package libKonogonka.Tools.NPDM;
|
|
|
|
import libKonogonka.Converter;
|
|
import org.apache.logging.log4j.LogManager;
|
|
import org.apache.logging.log4j.Logger;
|
|
|
|
import java.util.LinkedHashMap;
|
|
import java.util.LinkedList;
|
|
|
|
/*
|
|
NOTE: This implementation is extremely bad for using application as library. Use raw for own purposes.
|
|
|
|
NOTE:
|
|
KAC is set of 4-byes blocks
|
|
Consider them as uInt32 (Read as Little endian)
|
|
Look on the tail of each block (low bits). If tail is equals to mask like 0111111 then such block is related to one of the possible sections (KernelFlags etc.)
|
|
If it's related to the one of the blocks, then we could pick useful data from this block.
|
|
Example:
|
|
36 BYES on this section, then 9 blocks with len = 4-bytes each available
|
|
1 00-01-02-03
|
|
2 04-05-06-07
|
|
3 08-09-10-11
|
|
4 12-13-14-15
|
|
5 16-17-18-19
|
|
6 20-21-22-23
|
|
7 24-25-26-27
|
|
8 28-29-30-31
|
|
9 32-33-34-35
|
|
|
|
Possible patterns are:
|
|
Where '+' is useful data; '0' and '1' in low bytes are pattern.
|
|
Octal | Decimal
|
|
++++++++++++++++++++++++++++0111 | 7 <- KernelFlags
|
|
+++++++++++++++++++++++++++01111 | 15 <- SyscallMask
|
|
+++++++++++++++++++++++++0111111 | 63 <- MapIoOrNormalRange
|
|
++++++++++++++++++++++++01111111 | 127 <- MapNormalPage (RW)
|
|
++++++++++++++++++++011111111111 | 2+47 <- InterruptPair
|
|
++++++++++++++++++01111111111111 | 8191 <- ApplicationType
|
|
+++++++++++++++++011111111111111 | 16383 <- KernelReleaseVersion
|
|
++++++++++++++++0111111111111111 | 32767 <- HandleTableSize
|
|
+++++++++++++++01111111111111111 | 65535 <- DebugFlags
|
|
Other masks could be implemented by N in future (?).
|
|
|
|
Calculation example:
|
|
Dec 1 = 00000000000000000000000000000001
|
|
00100000000000000000000000000111 & 1 = 1
|
|
00010000000000000000000000000011 & 1 = 1
|
|
00001000000000000000000000000001 & 1 = 1
|
|
00000100000000000000000000000000 & 1 = 0
|
|
|
|
TIP: Generate
|
|
int j = 0xFFFFFFFF;
|
|
for (byte i = 0; i < 16; i++){
|
|
j = (j << 1);
|
|
RainbowHexDump.octDumpInt(~j);
|
|
}
|
|
*/
|
|
|
|
public class KernelAccessControlProvider {
|
|
private final static Logger log = LogManager.getLogger(KernelAccessControlProvider.class);
|
|
|
|
private static final int KERNELFLAGS = 3,
|
|
SYSCALLMASK = 4,
|
|
MAPIOORNORMALRANGE = 6,
|
|
MAPNORMALPAGE_RW = 7,
|
|
INTERRUPTPAIR = 11,
|
|
APPLICATIONTYPE = 13,
|
|
KERNELRELEASEVERSION = 14,
|
|
HANDLETABLESIZE = 15,
|
|
DEBUGFLAGS = 16;
|
|
// RAW data
|
|
private final LinkedList<Integer> rawData;
|
|
// Kernel flags
|
|
private boolean kernelFlagsAvailable;
|
|
private int kernelFlagCpuIdHi;
|
|
private int kernelFlagCpuIdLo;
|
|
private int kernelFlagThreadPrioHi;
|
|
private int kernelFlagThreadPrioLo;
|
|
// Syscall Masks as index | mask - order AS IS. [0] = bit5; [1] = bit6
|
|
private final LinkedHashMap<Byte, byte[]> syscallMasks; // Index, Mask
|
|
// MapIoOrNormalRange
|
|
private final LinkedHashMap<byte[], Boolean> mapIoOrNormalRange; // alt page+num, RO flag
|
|
// MapNormalPage (RW)
|
|
private byte[] mapNormalPage; // TODO: clarify is possible to have multiple
|
|
|
|
private final LinkedHashMap<Integer, byte[][]> interruptPairs; // Number; irq0, irq2
|
|
|
|
private int applicationType;
|
|
|
|
private boolean isKernelRelVersionAvailable;
|
|
private int kernelRelVersionMajor;
|
|
private int kernelRelVersionMinor;
|
|
|
|
private int handleTableSize;
|
|
// Debug flags
|
|
private boolean debugFlagsAvailable;
|
|
private boolean canBeDebugged;
|
|
private boolean canDebugOthers;
|
|
|
|
public KernelAccessControlProvider(byte[] bytes) throws Exception{
|
|
if (bytes.length < 4)
|
|
throw new Exception("ACID-> KernelAccessControlProvider: too small size of the Kernel Access Control");
|
|
|
|
this.rawData = new LinkedList<>();
|
|
this.interruptPairs = new LinkedHashMap<>();
|
|
this.syscallMasks = new LinkedHashMap<>();
|
|
this.mapIoOrNormalRange = new LinkedHashMap<>();
|
|
|
|
// Collect all blocks
|
|
for (int position = 0; position < bytes.length; position += 4) {
|
|
int block = Converter.getLEint(bytes, position);
|
|
|
|
rawData.add(block);
|
|
int type = findBitsCount(block);
|
|
switch (type){
|
|
case KERNELFLAGS:
|
|
kernelFlagsAvailable = true;
|
|
kernelFlagCpuIdHi = block >> 24;
|
|
kernelFlagCpuIdLo = block >> 16 & 0b11111111;
|
|
kernelFlagThreadPrioHi = block >> 10 & 0b111111;
|
|
kernelFlagThreadPrioLo = block >> 4 & 0b111111;
|
|
log.trace("KERNELFLAGS "+kernelFlagCpuIdHi+" "+kernelFlagCpuIdLo+" "+kernelFlagThreadPrioHi+" "+kernelFlagThreadPrioLo);
|
|
break;
|
|
case SYSCALLMASK:
|
|
byte maskTableIndex = (byte) (block >> 29 & 0b111); // declared as byte; max value could be 7; min - 0;
|
|
byte[] mask = new byte[24]; // Consider as bit.
|
|
log.trace("SYSCALLMASK ind: "+maskTableIndex);
|
|
|
|
for (int k = 28; k >= 5; k--) {
|
|
mask[k-5] = (byte) (block >> k & 1); // Only 1 or 0 possible
|
|
log.trace("["+(k-4)+"/24]\t" + mask[k-5]);
|
|
}
|
|
syscallMasks.put(maskTableIndex, mask);
|
|
break;
|
|
case MAPIOORNORMALRANGE:
|
|
byte[] altStPgNPgNum = new byte[24];
|
|
log.trace("MAPIOORNORMALRANGE Flag: "+((block >> 31 & 1) != 0));
|
|
|
|
for (int k = 30; k >= 7; k--){
|
|
altStPgNPgNum[k-7] = (byte) (block >> k & 1); // Only 1 or 0 possible
|
|
log.trace(" " + altStPgNPgNum[k-7]);
|
|
}
|
|
mapIoOrNormalRange.put(altStPgNPgNum, (block >> 31 & 1) != 0);
|
|
break;
|
|
case MAPNORMALPAGE_RW:
|
|
log.trace("MAPNORMALPAGE_RW\t");
|
|
mapNormalPage = new byte[24];
|
|
for (int k = 31; k >= 8; k--){
|
|
mapNormalPage[k-8] = (byte) (block >> k & 1);
|
|
log.trace(" " + mapNormalPage[k-8]);
|
|
}
|
|
break;
|
|
case INTERRUPTPAIR:
|
|
log.trace("INTERRUPTPAIR");
|
|
//RainbowHexDump.octDumpInt(block);
|
|
byte[][] pair = new byte[2][];
|
|
byte[] irq0 = new byte[10];
|
|
byte[] irq1 = new byte[10];
|
|
|
|
for (int k = 21; k >= 12; k--)
|
|
irq0[k-12] = (byte) (block >> k & 1);
|
|
for (int k = 31; k >= 22; k--)
|
|
irq1[k-22] = (byte) (block >> k & 1);
|
|
pair[0] = irq0;
|
|
pair[1] = irq1;
|
|
interruptPairs.put(interruptPairs.size(), pair);
|
|
break;
|
|
case APPLICATIONTYPE:
|
|
applicationType = block >> 14 & 0b111;
|
|
log.trace("APPLICATIONTYPE "+applicationType);
|
|
break;
|
|
case KERNELRELEASEVERSION:
|
|
log.trace("KERNELRELEASEVERSION\t"+(block >> 19 & 0b111111111111)+"."+(block >> 15 & 0b1111)+".X");
|
|
isKernelRelVersionAvailable = true;
|
|
kernelRelVersionMajor = (block >> 19 & 0b111111111111);
|
|
kernelRelVersionMinor = (block >> 15 & 0b1111);
|
|
break;
|
|
case HANDLETABLESIZE:
|
|
handleTableSize = block >> 16 & 0b1111111111;
|
|
log.trace("HANDLETABLESIZE "+handleTableSize);
|
|
break;
|
|
case DEBUGFLAGS:
|
|
debugFlagsAvailable = true;
|
|
canBeDebugged = (block >> 17 & 1) != 0;
|
|
canDebugOthers = (block >> 18 & 1) != 0;
|
|
log.trace("DEBUGFLAGS "+canBeDebugged+" "+canDebugOthers);
|
|
break;
|
|
default:
|
|
log.warn("INVALID ind:0b"+Integer.toBinaryString(block));
|
|
}
|
|
}
|
|
}
|
|
|
|
private int findBitsCount(int value){
|
|
int minBitCnt = 0;
|
|
for (int i = 0; i < 32; i++){
|
|
if((value & 1) == 0)
|
|
break;
|
|
value >>= 1;
|
|
minBitCnt++;
|
|
}
|
|
return minBitCnt;
|
|
}
|
|
public LinkedList<Integer> getRawData() { return rawData; }
|
|
public boolean isKernelFlagsAvailable() { return kernelFlagsAvailable; }
|
|
public int getKernelFlagCpuIdHi() { return kernelFlagCpuIdHi; }
|
|
public int getKernelFlagCpuIdLo() { return kernelFlagCpuIdLo; }
|
|
public int getKernelFlagThreadPrioHi() { return kernelFlagThreadPrioHi; }
|
|
public int getKernelFlagThreadPrioLo() { return kernelFlagThreadPrioLo; }
|
|
public LinkedHashMap<byte[], Boolean> getMapIoOrNormalRange() { return mapIoOrNormalRange; }
|
|
public byte[] getMapNormalPage() { return mapNormalPage; }
|
|
public LinkedHashMap<Integer, byte[][]> getInterruptPairs() { return interruptPairs; }
|
|
public int getApplicationType() { return applicationType; }
|
|
public boolean isKernelRelVersionAvailable() { return isKernelRelVersionAvailable; }
|
|
public int getKernelRelVersionMajor() { return kernelRelVersionMajor; }
|
|
public int getKernelRelVersionMinor() { return kernelRelVersionMinor;}
|
|
public int getHandleTableSize() { return handleTableSize; }
|
|
public boolean isDebugFlagsAvailable() { return debugFlagsAvailable; }
|
|
public boolean isCanBeDebugged() { return canBeDebugged; }
|
|
public boolean isCanDebugOthers() { return canDebugOthers; }
|
|
public LinkedHashMap<Byte, byte[]> getSyscallMasks() { return syscallMasks; }
|
|
}
|