github.com/linuxboot/fiano@v1.2.0/pkg/amd/manifest/embedded_firmware_structure_test.go (about)

     1  // Copyright 2019 the LinuxBoot Authors. All rights reserved
     2  // Use of this source code is governed by a BSD-style
     3  // license that can be found in the LICENSE file.
     4  
     5  package manifest
     6  
     7  import (
     8  	"testing"
     9  )
    10  
    11  const embeddedFirmwareStructureLength = 0x4A
    12  
    13  func TestFindEmbeddedFirmwareStructure(t *testing.T) {
    14  	embeddedFirmwareStructureDataChunk := []byte{
    15  		0xaa, 0x55, 0xaa, 0x55,
    16  
    17  		0x00, 0x00, 0x00, 0x00,
    18  		0x00, 0x00, 0x00, 0x00,
    19  		0x00, 0x00, 0x00, 0x00,
    20  		0x00, 0x00, 0x00, 0x00,
    21  
    22  		0xaa, 0xbb, 0xcc, 0xdd,
    23  
    24  		0x11, 0x22, 0x33, 0x44,
    25  		0x00, 0x00, 0x12, 0x34,
    26  		0x55, 0x66, 0x77, 0x88,
    27  		0x00, 0x00, 0x00, 0x00,
    28  		0xbb, 0xee, 0xaa, 0xff,
    29  	}
    30  	for len(embeddedFirmwareStructureDataChunk) < embeddedFirmwareStructureLength {
    31  		embeddedFirmwareStructureDataChunk = append(embeddedFirmwareStructureDataChunk, 0x00)
    32  	}
    33  
    34  	dummyPrefix := []byte{0x1, 0x2, 0x3, 0x4}
    35  	firmwareImage := append(dummyPrefix, embeddedFirmwareStructureDataChunk...)
    36  	firmware := newDummyFirmware(firmwareImage, t)
    37  	firmware.addMapping(
    38  		0xfffa0000, 0,
    39  	).addMapping(
    40  		0xfff20000, 0,
    41  	).addMapping(
    42  		0xffe20000, 0,
    43  	).addMapping(
    44  		0xffc20000, 0,
    45  	).addMapping(
    46  		0xff820000, 0,
    47  	).addMapping(
    48  		0xff020000, uint64(len(dummyPrefix)),
    49  	)
    50  
    51  	efs, r, err := FindEmbeddedFirmwareStructure(firmware)
    52  	if err != nil {
    53  		t.Fatalf("finding embedded firmware structure failed: '%v'", err)
    54  	}
    55  	if r.Offset != uint64(len(dummyPrefix)) {
    56  		t.Errorf("returned offset: '%d', expected: '%d'", r.Offset, len(dummyPrefix))
    57  	}
    58  	if r.Length != embeddedFirmwareStructureLength {
    59  		t.Errorf("returned length: '%d', expected: '%d'", r.Length, embeddedFirmwareStructureLength)
    60  	}
    61  	if efs == nil {
    62  		t.Fatalf("result embedded firmware structure is nil")
    63  	}
    64  	if efs.Signature != EmbeddedFirmwareStructureSignature {
    65  		t.Errorf("actual EFS.signature: '%X', expected: '%X'", efs.Signature, EmbeddedFirmwareStructureSignature)
    66  	}
    67  	if efs.PSPDirectoryTablePointer != 0xddccbbaa {
    68  		t.Errorf("actual efs.PSPDirectoryTablePointer: '%X', expected: '%X'", efs.PSPDirectoryTablePointer, 0xddccbbaa)
    69  	}
    70  	if efs.BIOSDirectoryTableFamily17hModels00h0FhPointer != 0x44332211 {
    71  		t.Errorf("actual EFS.BIOSDirectoryTableFamily17hModels00h0FhPointer: '%X', expected: '%X'", efs.BIOSDirectoryTableFamily17hModels00h0FhPointer, 0x44332211)
    72  	}
    73  	if efs.BIOSDirectoryTableFamily17hModels10h1FhPointer != 0x34120000 {
    74  		t.Errorf("actual EFS.BIOSDirectoryTableFamily17hModels10h1FhPointer: '%X', expected: '%X'", efs.BIOSDirectoryTableFamily17hModels10h1FhPointer, 0x34120000)
    75  	}
    76  	if efs.BIOSDirectoryTableFamily17hModels30h3FhPointer != 0x88776655 {
    77  		t.Errorf("actual EFS.BIOSDirectoryTableFamily17hModels30h3FhPointer: '%X', expected: '%X'", efs.BIOSDirectoryTableFamily17hModels30h3FhPointer, 0x88776655)
    78  	}
    79  	if efs.BIOSDirectoryTableFamily17hModels60h3FhPointer != 0xffaaeebb {
    80  		t.Errorf("actual EFS.BIOSDirectoryTableFamily17hModels60h3FhPointer: '%X', expected: '%X'", efs.BIOSDirectoryTableFamily17hModels60h3FhPointer, 0xffaaeebb)
    81  	}
    82  }
    83  
    84  type dummyFirmware struct {
    85  	image []byte
    86  	t     *testing.T
    87  
    88  	physToOffset map[uint64]uint64
    89  	offsetToPhys map[uint64]uint64
    90  }
    91  
    92  func newDummyFirmware(image []byte, t *testing.T) *dummyFirmware {
    93  	return &dummyFirmware{
    94  		image:        image,
    95  		t:            t,
    96  		physToOffset: make(map[uint64]uint64),
    97  		offsetToPhys: make(map[uint64]uint64),
    98  	}
    99  }
   100  
   101  func (f *dummyFirmware) addMapping(physAddr, offset uint64) *dummyFirmware {
   102  	f.physToOffset[physAddr] = offset
   103  	f.offsetToPhys[offset] = physAddr
   104  	return f
   105  }
   106  
   107  func (f *dummyFirmware) ImageBytes() []byte {
   108  	return f.image
   109  }
   110  
   111  func (f *dummyFirmware) PhysAddrToOffset(physAddr uint64) uint64 {
   112  	result, found := f.physToOffset[physAddr]
   113  	if !found {
   114  		f.t.Fatalf("physical address '%d' could not be mapped", physAddr)
   115  	}
   116  	return result
   117  }
   118  
   119  func (f *dummyFirmware) OffsetToPhysAddr(offset uint64) uint64 {
   120  	result, found := f.offsetToPhys[offset]
   121  	if !found {
   122  		f.t.Fatalf("image offset '%d' could not be mapped", offset)
   123  	}
   124  	return result
   125  }