cgcef_verify

#!/usr/bin/env python

import os
import struct
import sys

PAGE_SIZE = 4096
DECREE_FLAG_ADDR = 0x4347C000
DECREE_FLAG_SZ = PAGE_SIZE

class ReadError(Exception):
    pass


def main():
    if len(sys.argv) != 2:
        sys.stderr.write("Usage: %s filename\n" % sys.argv[0]);
        return 1
    try:
        r = valid_cgc_executable_file(sys.argv[1])
    except ReadError:
        r = False

    if not r:
        return 1
    return 0

def roundup(x, y):
    if x % y == 0:
        return x
    else:
        return x + y - (x % y)

def valid_cgc_executable_file(filename):
    filp = open(filename, "r")

    r = verify_ident(filp)
    if not r and verify_header(filp):
        r = -1
    if not r and verify_section_hdrs(filp):
        r = -1
    if not r and verify_program_hdrs(filp):
        r = -1

    filp.close()
    if r:
        print("ERROR: not a DECREE executable")
        return False
    return True

def verify_ident(filp):
    CGCEFMAG0 = 0x7f
    CGCEFMAG1 = 'C'
    CGCEFMAG2 = 'G'
    CGCEFMAG3 = 'C'
    CGCEFCLASS32 = 1
    CGCEFDATA2LSB = 1
    CGCEFVERSION = 1
    CGCEFOSABI_CGCOS = 0x43
    CGCEFABIVERSION = 1

    r = 0

    buf = read_bytes(filp, 0, 9)
    (cgcef_mag0, cgcef_mag1, cgcef_mag2, cgcef_mag3, cgcef_class, cgcef_data,
     cgcef_version, cgcef_osabi, cgcef_abiversion) =                        \
     struct.unpack("<bcccbbbbb", buf)

    if cgcef_mag0 != CGCEFMAG0 or cgcef_mag1 != CGCEFMAG1 or                \
       cgcef_mag2 != CGCEFMAG2 or cgcef_mag3 != CGCEFMAG3:
        warnx("did not identify as a DECREE binary (ident %s%s%s)" %
              (cgcef_mag1, cgcef_mag2, cgcef_mag3))
        return -1
    if cgcef_class != CGCEFCLASS32:
        warnx("did not identify as a 32bit binary")
        r = -1
    if cgcef_data != CGCEFDATA2LSB:
        warnx("did not identify as a little endian binary")
        r = -1
    if cgcef_version != CGCEFVERSION:
        warnx("unknown CGCEF version")
        r = -1
    if cgcef_osabi != CGCEFOSABI_CGCOS:
        warnx("did not identify as a DECREE ABI binary")
        r = -1
    if cgcef_abiversion != CGCEFABIVERSION:
        warnx("did not identify as a v1 DECREE ABI binary")
        r = -1
    return r

def verify_header(filp):
    header_size = 16 + 2*2 + 4*5 + 2*6
    buf = read_bytes(filp, 0, header_size)
    (cgcef_type, cgcef_machine, cgcef_version, cgcef_entry, cgcef_phoff,
     cgcef_shoff, cgcef_flags, cgcef_ehsize, cgcef_phentsize, cgcef_phnum,
     cgcef_shentsize, cgcef_shnum, cgcef_shstrndx) =                        \
     struct.unpack("<xxxxxxxxxxxxxxxxHHLLLLLHHHHHH", buf)

    ET_EXEC = 2
    EM_386 = 3
    EV_CURRENT = 1
    r = 0
    if cgcef_ehsize != header_size:
        warnx("invalid header size")
        r = -1
    if cgcef_type != ET_EXEC:
        warnx("did not identify as an executable")
        r = -1
    if cgcef_machine != EM_386:
        warnx("did not identify as i386")
        r = -1
    if cgcef_version != EV_CURRENT:
        warnx("did not identify as a version 1 binary")
        r = -1
    if cgcef_flags != 0:
        warnx("contained unsupported flags")
        r = -1
    return r 

def verify_section_hdrs(filp):
    header_size = 16 + 2*2 + 4*5 + 2*6
    buf = read_bytes(filp, 0, header_size)
    (cgcef_type, cgcef_machine, cgcef_version, cgcef_entry, cgcef_phoff,
     cgcef_shoff, cgcef_flags, cgcef_ehsize, cgcef_phentsize, cgcef_phnum,
     cgcef_shentsize, cgcef_shnum, cgcef_shstrndx) =                        \
     struct.unpack("<xxxxxxxxxxxxxxxxHHIIIIIHHHHHH", buf)

    return 0;

def verify_program_hdrs(filp):
    header_size = 16 + 2*2 + 4*5 + 2*6
    buf = read_bytes(filp, 0, header_size)
    (cgcef_type, cgcef_machine, cgcef_version, cgcef_entry, cgcef_phoff,
     cgcef_shoff, cgcef_flags, cgcef_ehsize, cgcef_phentsize, cgcef_phnum,
     cgcef_shentsize, cgcef_shnum, cgcef_shstrndx) =                        \
     struct.unpack("<xxxxxxxxxxxxxxxxHHLLLLLHHHHHH", buf)

    phent_size = 8 * 4

    r = 0
    if cgcef_phnum == 0:
        warnx("No program headers")
        r = -1
    if cgcef_phentsize != phent_size:
        warnx("Invalid program header size")
        r = -1

    PT_NULL = 0
    PT_LOAD = 1
    PT_PHDR = 6
    PT_GNU_STACK = 0x60000000 + 0x474e551
    PT_CGCPOV2 = 0x6ccccccc
    for i in xrange(0, cgcef_phnum):
        hdr = read_bytes(filp, cgcef_phoff + phent_size * i, phent_size)
        (p_type, p_offset, p_vaddr, p_paddr, p_filesz, p_memsz, p_flags,
         p_align) = struct.unpack("<IIIIIIII", hdr)


	# Check for overlaps with the magic flag page
	p_vaddr_page = p_vaddr & ~(PAGE_SIZE-1)
	if p_memsz == 0:
		p_vaddr_sz = PAGE_SIZE
	else:
		p_vaddr_sz = roundup(p_memsz, PAGE_SIZE)
	if (DECREE_FLAG_ADDR >= p_vaddr_page and
	    DECREE_FLAG_ADDR < p_vaddr_page + p_vaddr_sz) or \
	   (DECREE_FLAG_ADDR + DECREE_FLAG_SZ > p_vaddr_page and
	    DECREE_FLAG_ADDR + DECREE_FLAG_SZ < p_vaddr_page + p_vaddr_sz) or \
	   (p_vaddr_page >= DECREE_FLAG_ADDR and
	    p_vaddr_page < DECREE_FLAG_ADDR + DECREE_FLAG_SZ) or \
	   (p_vaddr_page + p_vaddr_sz > DECREE_FLAG_ADDR and
	    p_vaddr_page + p_vaddr_sz < DECREE_FLAG_ADDR + DECREE_FLAG_SZ):
            warnx("Program header #%d@%xh collides with flag page" % (i, p_vaddr))
            r = -1

        if p_type == PT_NULL or     \
           p_type == PT_LOAD or     \
           p_type == PT_PHDR or     \
           p_type == PT_CGCPOV2:
            pass
        else:
            warnx("Invalid program header #%d %xh." % (i, p_type))
            r = -1

    return r


def read_bytes(filp, offset, size):
    filp.seek(offset, 0);    # absolute offset seek
    buf = filp.read(size)
    if len(buf) != size:
        raise ReadError("Short read")
    return buf

def warnx(str):
    sys.stderr.write(os.path.basename(sys.argv[0]) + ":" + " " + str + "\n")
    

if __name__ == '__main__':
    sys.exit(main())