forks/go-ethereum
1
0
Fork 1
mirror of https://github.com/ethereum/go-ethereum.git synced 2026-07-25 14:16:44 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

move c code to a separate c file

Browse source
This commit is contained in:
Kevaundray Wedderburn 2025-07-08 22:46:06 +01:00
parent f8cd00314e
commit ee5e4361ea
3 changed files with 140 additions and 158 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

228
crypto/modexp/gmp/gmp.go
View file

@ -1,168 +1,80 @@
package gmp package gmp
// #cgo LDFLAGS: -lgmp // #cgo LDFLAGS: -lgmp
// #include <gmp.h> // #include "modexp.h"
// #include <stdlib.h>
// #include <string.h>
// #include <stdint.h>
//
// static int modexp_bytes(
// const uint8_t* base, size_t base_len,
// const uint8_t* exp, size_t exp_len,
// const uint8_t* mod, size_t mod_len,
// uint8_t* result, size_t* result_len)
// {
// mpz_t base_mpz, exp_mpz, mod_mpz, result_mpz;
//
// // Check for NULL pointers
// if (!base || !exp || !mod || !result || !result_len) {
// return -1;
// }
//
// // Initialize GMP integers
// mpz_inits(base_mpz, exp_mpz, mod_mpz, result_mpz, NULL);
//
// // Import big-endian byte arrays into GMP integers
// // Handle empty arrays specially - GMP treats NULL with size 0 as 0
// if (base_len > 0) {
// mpz_import(base_mpz, base_len, 1, 1, 0, 0, base);
// }
// if (exp_len > 0) {
// mpz_import(exp_mpz, exp_len, 1, 1, 0, 0, exp);
// }
// if (mod_len > 0) {
// mpz_import(mod_mpz, mod_len, 1, 1, 0, 0, mod);
// }
//
// // Perform modular exponentiation
// mpz_powm(result_mpz, base_mpz, exp_mpz, mod_mpz);
//
// // Get exact size needed for result
// size_t needed = 0;
// mpz_export(NULL, &needed, 1, 1, 0, 0, result_mpz);
//
// // Check if result buffer is large enough
// if (*result_len < needed) {
// mpz_clears(base_mpz, exp_mpz, mod_mpz, result_mpz, NULL);
// return -2;
// }
//
// // Export result to big-endian byte array
// mpz_export(result, &needed, 1, 1, 0, 0, result_mpz);
// *result_len = needed;
//
// // Clean up
// mpz_clears(base_mpz, exp_mpz, mod_mpz, result_mpz, NULL);
//
// return 0;
// }
import "C" import "C"
import ( import (
"errors" "errors"
"runtime" "runtime"
"unsafe" "unsafe"
) )
// ModExp performs modular exponentiation using GMP
// ModExp performs modular exponentiation using the C implementation directly
// This is a lower-level function that bypasses the Go wrapper types
//
// This is thread safe. // This is thread safe.
func ModExp(base, exp, mod []byte) ([]byte, error) { func ModExp(base, exp, mod []byte) ([]byte, error) {
// Handle empty modulus - return empty result (EVM behavior) // Handle empty modulus - return empty result (EVM behavior)
if len(mod) == 0 { if len(mod) == 0 {
return []byte{}, nil return []byte{}, nil
} }
// Special case: zero modulus // Special case: zero modulus
// TODO: Check to see if theres a cleaner way to do this allZero := true
allZero := true for _, b := range mod {
for _, b := range mod { if b != 0 {
if b != 0 { allZero = false
allZero = false break
break }
} }
} if allZero {
if allZero { return []byte{}, nil
return []byte{}, nil }
}
// Allocate result buffer (size of modulus is the max possible result)
// // Special case: base == 1 result := make([]byte, len(mod))
// // Check if base is 1 (only one byte with value 1, or leading zeros followed by 1) resultLen := C.size_t(len(result))
// baseIsOne := false
// if len(base) == 0 { // Handle empty slices - pass a dummy non-nil pointer with length 0
// baseIsOne = false // This avoids UB when the length is zero.
// } else if len(base) == 1 && base[0] == 1 { dummy := C.uint8_t(0)
// baseIsOne = true var basePtr, expPtr, modPtr *C.uint8_t = &dummy, &dummy, &dummy
// } else {
// // Check for leading zeros followed by 1 if len(base) > 0 {
// allZeroExceptLast := true basePtr = (*C.uint8_t)(unsafe.Pointer(&base[0]))
// for i := 0; i < len(base)-1; i++ { }
// if base[i] != 0 { if len(exp) > 0 {
// allZeroExceptLast = false expPtr = (*C.uint8_t)(unsafe.Pointer(&exp[0]))
// break }
// } if len(mod) > 0 {
// } modPtr = (*C.uint8_t)(unsafe.Pointer(&mod[0]))
// if allZeroExceptLast && base[len(base)-1] == 1 { }
// baseIsOne = true
// } // Call C function
// } ret := C.modexp_bytes(
basePtr, C.size_t(len(base)),
// if baseIsOne { expPtr, C.size_t(len(exp)),
// // base^exp mod mod = 1 mod mod = 1 (if mod > 1), 0 (if mod == 1) modPtr, C.size_t(len(mod)),
// // Just return base % mod which is 1 % mod (*C.uint8_t)(unsafe.Pointer(&result[0])), &resultLen,
// if len(mod) == 1 && mod[0] == 1 { )
// return []byte{}, nil // 1 % 1 = 0
// } // Keep the slices alive until after the C call completes
// return []byte{1}, nil // 1 % mod = 1 for mod > 1 runtime.KeepAlive(base)
// } runtime.KeepAlive(exp)
runtime.KeepAlive(mod)
// Allocate result buffer (size of modulus is the max possible result) runtime.KeepAlive(result)
result := make([]byte, len(mod))
resultLen := C.size_t(len(result)) // Check for errors
switch ret {
// Handle empty slices - pass a dummy non-nil pointer with length 0 case 0:
// This avoids UB when the length is zero. // Success - trim result to actual size
dummy := C.uint8_t(0) if resultLen == 0 {
var basePtr, expPtr, modPtr *C.uint8_t = &dummy, &dummy, &dummy return []byte{}, nil
}
if len(base) > 0 { return result[:resultLen], nil
basePtr = (*C.uint8_t)(unsafe.Pointer(&base[0])) case -1:
} return nil, errors.New("invalid parameter")
if len(exp) > 0 { case -2:
expPtr = (*C.uint8_t)(unsafe.Pointer(&exp[0])) return nil, errors.New("result buffer too small")
} default:
if len(mod) > 0 { return nil, errors.New("unknown error")
modPtr = (*C.uint8_t)(unsafe.Pointer(&mod[0])) }
}
// Call C function
ret := C.modexp_bytes(
basePtr, C.size_t(len(base)),
expPtr, C.size_t(len(exp)),
modPtr, C.size_t(len(mod)),
(*C.uint8_t)(unsafe.Pointer(&result[0])), &resultLen,
)
// Keep the slices alive until after the C call completes
runtime.KeepAlive(base)
runtime.KeepAlive(exp)
runtime.KeepAlive(mod)
runtime.KeepAlive(result)
// Check for errors
switch ret {
case 0:
// Success - trim result to actual size
if resultLen == 0 {
return []byte{}, nil
}
return result[:resultLen], nil
case -1:
return nil, errors.New("invalid parameter")
case -2:
return nil, errors.New("result buffer too small")
default:
return nil, errors.New("unknown error")
}
} }

55
crypto/modexp/gmp/modexp.c Normal file
View file

@ -0,0 +1,55 @@
#include <gmp.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
int modexp_bytes(
const uint8_t* base, size_t base_len,
const uint8_t* exp, size_t exp_len,
const uint8_t* mod, size_t mod_len,
uint8_t* result, size_t* result_len)
{
mpz_t base_mpz, exp_mpz, mod_mpz, result_mpz;
// Check for NULL pointers
if (!base || !exp || !mod || !result || !result_len) {
return -1;
}
// Initialize GMP integers
mpz_inits(base_mpz, exp_mpz, mod_mpz, result_mpz, NULL);
// Import big-endian byte arrays into GMP integers
// Handle empty arrays specially - GMP treats NULL with size 0 as 0
if (base_len > 0) {
mpz_import(base_mpz, base_len, 1, 1, 0, 0, base);
}
if (exp_len > 0) {
mpz_import(exp_mpz, exp_len, 1, 1, 0, 0, exp);
}
if (mod_len > 0) {
mpz_import(mod_mpz, mod_len, 1, 1, 0, 0, mod);
}
// Perform modular exponentiation
mpz_powm(result_mpz, base_mpz, exp_mpz, mod_mpz);
// Get exact size needed for result
size_t needed = 0;
mpz_export(NULL, &needed, 1, 1, 0, 0, result_mpz);
// Check if result buffer is large enough
if (*result_len < needed) {
mpz_clears(base_mpz, exp_mpz, mod_mpz, result_mpz, NULL);
return -2;
}
// Export result to big-endian byte array
mpz_export(result, &needed, 1, 1, 0, 0, result_mpz);
*result_len = needed;
// Clean up
mpz_clears(base_mpz, exp_mpz, mod_mpz, result_mpz, NULL);
return 0;
}

15
crypto/modexp/gmp/modexp.h Normal file
View file

@ -0,0 +1,15 @@
#ifndef MODEXP_H
#define MODEXP_H
#include <stdint.h>
#include <stddef.h>
// Perform modular exponentiation: base^exp mod mod
// Returns 0 on success, -1 on invalid input, -2 if result buffer too small
int modexp_bytes(
const uint8_t* base, size_t base_len,
const uint8_t* exp, size_t exp_len,
const uint8_t* mod, size_t mod_len,
uint8_t* result, size_t* result_len);
#endif // MODEXP_H