Skip to content

Commit 5117584

Browse files
justsmthjustsmth
committed
Common code in fipscommon
1 parent b92cfae commit 5117584

4 files changed

Lines changed: 106 additions & 133 deletions

File tree

‎tests/ci/run_windows_tests.bat‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -77,8 +77,8 @@ if not errorlevel 1 (
7777
goto error
7878
)
7979
copy /y %BUILD_DIR%\crypto\crypto.dll.bak %BUILD_DIR%\crypto\crypto.dll || goto error
80-
del %BUILD_DIR%\crypto\crypto.dll.bak
81-
del %BUILD_DIR%\crypto\crypto_corrupted.dll
80+
del /q %BUILD_DIR%\crypto\crypto.dll.bak
81+
del /q %BUILD_DIR%\crypto\crypto_corrupted.dll
8282

8383
@echo LOG: %date%-%time% %1 %2 FIPS validation complete
8484
exit /b 0

‎util/fipstools/break-hash.go‎

Lines changed: 7 additions & 66 deletions
Original file line numberDiff line numberDiff line change
@@ -12,45 +12,14 @@ import (
1212
"crypto/hmac"
1313
"crypto/sha512"
1414
"debug/elf"
15-
"debug/pe"
1615
"encoding/hex"
1716
"errors"
1817
"flag"
1918
"fmt"
2019
"os"
21-
"strconv"
22-
"strings"
23-
)
24-
25-
func parseMapFile(mapPath string) (map[string]uint64, error) {
26-
data, err := os.ReadFile(mapPath)
27-
if err != nil {
28-
return nil, fmt.Errorf("failed to read map file: %s", err.Error())
29-
}
30-
31-
symbols := make(map[string]uint64)
32-
// Symbol lines have format: SSSS:OOOOOOOO name RRRRRRRRRRRRRRRR Lib:Object
33-
for _, line := range strings.Split(string(data), "\n") {
34-
fields := strings.Fields(line)
35-
if len(fields) < 3 || !strings.Contains(fields[0], ":") {
36-
continue
37-
}
38-
name := fields[1]
39-
if !strings.HasPrefix(name, "BORINGSSL_bcm_") {
40-
continue
41-
}
42-
rvaBase, err := strconv.ParseUint(fields[2], 16, 64)
43-
if err != nil {
44-
return nil, fmt.Errorf("failed to parse Rva+Base for symbol %q: %s", name, err.Error())
45-
}
46-
if _, exists := symbols[name]; exists {
47-
return nil, fmt.Errorf("duplicate symbol %q in map file", name)
48-
}
49-
symbols[name] = rvaBase
50-
}
5120

52-
return symbols, nil
53-
}
21+
"github.com/aws/aws-lc/util/fipstools/fipscommon"
22+
)
5423

5524
func doELF(objectBytes []byte) (int, []byte, error) {
5625
object, err := elf.NewFile(bytes.NewReader(objectBytes))
@@ -135,49 +104,21 @@ func doELF(objectBytes []byte) (int, []byte, error) {
135104
}
136105

137106
func doPE(objectBytes []byte, mapPath string) (int, []byte, error) {
138-
symbolAddrs, err := parseMapFile(mapPath)
107+
symbolAddrs, err := fipscommon.ParseMapFile(mapPath)
139108
if err != nil {
140109
return 0, nil, err
141110
}
142111

143-
peFile, err := pe.NewFile(bytes.NewReader(objectBytes))
112+
peInfo, err := fipscommon.ParsePE(objectBytes)
144113
if err != nil {
145-
return 0, nil, fmt.Errorf("failed to parse PE: %s", err.Error())
146-
}
147-
148-
var imageBase uint64
149-
switch oh := peFile.OptionalHeader.(type) {
150-
case *pe.OptionalHeader64:
151-
imageBase = oh.ImageBase
152-
case *pe.OptionalHeader32:
153-
imageBase = uint64(oh.ImageBase)
154-
default:
155-
return 0, nil, errors.New("unsupported PE optional header type")
156-
}
157-
158-
resolveOffset := func(name string) (uint64, error) {
159-
addr, ok := symbolAddrs[name]
160-
if !ok {
161-
return 0, fmt.Errorf("symbol %q not found in map file", name)
162-
}
163-
if addr < imageBase {
164-
return 0, fmt.Errorf("symbol %q address 0x%x is below image base 0x%x", name, addr, imageBase)
165-
}
166-
rva := addr - imageBase
167-
for _, s := range peFile.Sections {
168-
start := uint64(s.VirtualAddress)
169-
if rva >= start && rva < start+uint64(s.VirtualSize) {
170-
return rva - start + uint64(s.Offset), nil
171-
}
172-
}
173-
return 0, fmt.Errorf("RVA 0x%x for %q not found in any PE section", rva, name)
114+
return 0, nil, err
174115
}
175116

176-
startOffset, err := resolveOffset("BORINGSSL_bcm_text_start")
117+
startOffset, err := peInfo.ResolveSymbolFileOffset(symbolAddrs, "BORINGSSL_bcm_text_start")
177118
if err != nil {
178119
return 0, nil, err
179120
}
180-
endOffset, err := resolveOffset("BORINGSSL_bcm_text_end")
121+
endOffset, err := peInfo.ResolveSymbolFileOffset(symbolAddrs, "BORINGSSL_bcm_text_end")
181122
if err != nil {
182123
return 0, nil, err
183124
}

‎util/fipstools/fipscommon/pe.go‎

Lines changed: 92 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,92 @@
1+
// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
2+
// SPDX-License-Identifier: Apache-2.0 OR ISC
3+
4+
package fipscommon
5+
6+
import (
7+
"bytes"
8+
"debug/pe"
9+
"errors"
10+
"fmt"
11+
"os"
12+
"strconv"
13+
"strings"
14+
)
15+
16+
// PEInfo holds parsed PE file information needed for symbol resolution.
17+
type PEInfo struct {
18+
File *pe.File
19+
ImageBase uint64
20+
}
21+
22+
// ParseMapFile reads a Windows linker map file and returns a map of
23+
// BORINGSSL_bcm_* symbol names to their Rva+Base addresses.
24+
func ParseMapFile(mapPath string) (map[string]uint64, error) {
25+
data, err := os.ReadFile(mapPath)
26+
if err != nil {
27+
return nil, fmt.Errorf("failed to read map file: %s", err.Error())
28+
}
29+
30+
symbols := make(map[string]uint64)
31+
// Symbol lines have format: SSSS:OOOOOOOO name RRRRRRRRRRRRRRRR Lib:Object
32+
for _, line := range strings.Split(string(data), "\n") {
33+
fields := strings.Fields(line)
34+
if len(fields) < 3 || !strings.Contains(fields[0], ":") {
35+
continue
36+
}
37+
name := fields[1]
38+
if !strings.HasPrefix(name, "BORINGSSL_bcm_") {
39+
continue
40+
}
41+
rvaBase, err := strconv.ParseUint(fields[2], 16, 64)
42+
if err != nil {
43+
return nil, fmt.Errorf("failed to parse Rva+Base for symbol %q: %s", name, err.Error())
44+
}
45+
if _, exists := symbols[name]; exists {
46+
return nil, fmt.Errorf("duplicate symbol %q in map file", name)
47+
}
48+
symbols[name] = rvaBase
49+
}
50+
51+
return symbols, nil
52+
}
53+
54+
// ParsePE parses a PE file from raw bytes and extracts the image base.
55+
func ParsePE(objectBytes []byte) (*PEInfo, error) {
56+
peFile, err := pe.NewFile(bytes.NewReader(objectBytes))
57+
if err != nil {
58+
return nil, fmt.Errorf("failed to parse PE: %s", err.Error())
59+
}
60+
61+
var imageBase uint64
62+
switch oh := peFile.OptionalHeader.(type) {
63+
case *pe.OptionalHeader64:
64+
imageBase = oh.ImageBase
65+
case *pe.OptionalHeader32:
66+
imageBase = uint64(oh.ImageBase)
67+
default:
68+
return nil, errors.New("unsupported PE optional header type")
69+
}
70+
71+
return &PEInfo{File: peFile, ImageBase: imageBase}, nil
72+
}
73+
74+
// ResolveSymbolFileOffset converts a symbol's Rva+Base address (from a linker
75+
// map file) to a file offset within the PE binary.
76+
func (p *PEInfo) ResolveSymbolFileOffset(symbolAddrs map[string]uint64, name string) (uint64, error) {
77+
addr, ok := symbolAddrs[name]
78+
if !ok {
79+
return 0, fmt.Errorf("symbol %q not found in map file", name)
80+
}
81+
if addr < p.ImageBase {
82+
return 0, fmt.Errorf("symbol %q address 0x%x is below image base 0x%x", name, addr, p.ImageBase)
83+
}
84+
rva := addr - p.ImageBase
85+
for _, s := range p.File.Sections {
86+
start := uint64(s.VirtualAddress)
87+
if rva >= start && rva < start+uint64(s.VirtualSize) {
88+
return rva - start + uint64(s.Offset), nil
89+
}
90+
}
91+
return 0, fmt.Errorf("RVA 0x%x for %q not found in any PE section", rva, name)
92+
}

‎util/fipstools/inject_hash/inject_hash.go‎

Lines changed: 5 additions & 65 deletions
Original file line numberDiff line numberDiff line change
@@ -12,14 +12,12 @@ import (
1212
"crypto/sha256"
1313
"debug/elf"
1414
"debug/macho"
15-
"debug/pe"
1615
"encoding/binary"
1716
"errors"
1817
"flag"
1918
"fmt"
2019
"io"
2120
"os"
22-
"strconv"
2321
"strings"
2422

2523
"github.com/aws/aws-lc/util/ar"
@@ -299,81 +297,23 @@ func doAppleOS(objectBytes []byte) ([]byte, []byte, error) {
299297
return moduleText, moduleROData, nil
300298
}
301299

302-
func parseMapFile(mapPath string) (map[string]uint64, error) {
303-
data, err := os.ReadFile(mapPath)
304-
if err != nil {
305-
return nil, fmt.Errorf("failed to read map file: %s", err.Error())
306-
}
307-
308-
symbols := make(map[string]uint64)
309-
// Symbol lines have format: SSSS:OOOOOOOO name RRRRRRRRRRRRRRRR Lib:Object
310-
for _, line := range strings.Split(string(data), "\n") {
311-
fields := strings.Fields(line)
312-
if len(fields) < 3 || !strings.Contains(fields[0], ":") {
313-
continue
314-
}
315-
name := fields[1]
316-
if !strings.HasPrefix(name, "BORINGSSL_bcm_") {
317-
continue
318-
}
319-
rvaBase, err := strconv.ParseUint(fields[2], 16, 64)
320-
if err != nil {
321-
return nil, fmt.Errorf("failed to parse Rva+Base for symbol %q: %s", name, err.Error())
322-
}
323-
if _, exists := symbols[name]; exists {
324-
return nil, fmt.Errorf("duplicate symbol %q in map file", name)
325-
}
326-
symbols[name] = rvaBase
327-
}
328-
329-
return symbols, nil
330-
}
331-
332300
func doWindows(objectBytes []byte, mapPath string) ([]byte, []byte, error) {
333-
symbolAddrs, err := parseMapFile(mapPath)
301+
symbolAddrs, err := fipscommon.ParseMapFile(mapPath)
334302
if err != nil {
335303
return nil, nil, err
336304
}
337305

338-
peFile, err := pe.NewFile(bytes.NewReader(objectBytes))
306+
peInfo, err := fipscommon.ParsePE(objectBytes)
339307
if err != nil {
340-
return nil, nil, fmt.Errorf("failed to parse PE: %s", err.Error())
341-
}
342-
343-
var imageBase uint64
344-
switch oh := peFile.OptionalHeader.(type) {
345-
case *pe.OptionalHeader64:
346-
imageBase = oh.ImageBase
347-
case *pe.OptionalHeader32:
348-
imageBase = uint64(oh.ImageBase)
349-
default:
350-
return nil, nil, errors.New("unsupported PE optional header type")
351-
}
352-
353-
resolveOffset := func(name string) (uint64, error) {
354-
addr, ok := symbolAddrs[name]
355-
if !ok {
356-
return 0, fmt.Errorf("symbol %q not found in map file", name)
357-
}
358-
if addr < imageBase {
359-
return 0, fmt.Errorf("symbol %q address 0x%x is below image base 0x%x", name, addr, imageBase)
360-
}
361-
rva := addr - imageBase
362-
for _, s := range peFile.Sections {
363-
start := uint64(s.VirtualAddress)
364-
if rva >= start && rva < start+uint64(s.VirtualSize) {
365-
return rva - start + uint64(s.Offset), nil
366-
}
367-
}
368-
return 0, fmt.Errorf("RVA 0x%x for %q not found in any PE section", rva, name)
308+
return nil, nil, err
369309
}
370310

371311
extractRegion := func(startSym, endSym string) ([]byte, error) {
372-
startOff, err := resolveOffset(startSym)
312+
startOff, err := peInfo.ResolveSymbolFileOffset(symbolAddrs, startSym)
373313
if err != nil {
374314
return nil, err
375315
}
376-
endOff, err := resolveOffset(endSym)
316+
endOff, err := peInfo.ResolveSymbolFileOffset(symbolAddrs, endSym)
377317
if err != nil {
378318
return nil, err
379319
}

0 commit comments

Comments
 (0)