fully clean unsafe.Pointer usage against checkptr

pkg/powershell/chelpers.go

@@ -14,15 +14,20 @@ func makeUintptrFromUint64(v uint64) uintptr {
 func allocWrapper(size uint64) (uintptr, error) {
 	return nativePowerShell_DefaultAlloc(size)
 }
+
+func localAllocWrapper(size uint64) (uintptr, error) {
+	return localAlloc(size)
+}
+
 func freeWrapper(v uintptr) {
 	nativePowerShell_DefaultFree(v)
 }
 
-func mallocCopyLogStringHolder(input nativePowerShell_LogString_Holder) uintptr {
+func localMallocCopyLogStringHolder(input nativePowerShell_LogString_Holder) uintptr {
 
 	size := uint64(unsafe.Sizeof(input))
 
-	data, err := allocWrapper(size)
+	data, err := localAllocWrapper(size)
 	if err != nil {
 		panic("Couldn't allocate memory")
 	}
@@ -32,16 +37,21 @@ func mallocCopyLogStringHolder(input nativePowerShell_LogString_Holder) uintptr
 	return data
 }
 
-func mallocCopyGenericPowerShellObject(input *nativePowerShell_GenericPowerShellObject, inputCount uint64) uintptr {
+func mallocCopyArrayGenericPowerShellObject(input []nativePowerShell_GenericPowerShellObject) uintptr {
+
+	inputCount := uint64(len(input))
 
-	size := inputCount * uint64(unsafe.Sizeof(*input))
+	var size uint64
+	if inputCount != 0 {
+		size = inputCount * uint64(unsafe.Sizeof(input[0]))
+	}
 
 	data, err := allocWrapper(size)
 	if err != nil {
 		panic("Couldn't allocate memory")
 	}
 
-	_ = memcpyGenericPowerShellObject(data, input, size)
+	_ = memcpyGenericPowerShellObject(data, &input[0], size)
 
 	return data
 }
@@ -63,7 +73,7 @@ func wsclen(str uintptr) uint64 {
 	var charCode uint16 = 1
 	var i uint64 = 0
 	for ; charCode != 0; i++ {
-		charCode = *((*uint16)(unsafe.Pointer(str + (makeUintptrFromUint64(i) * unsafe.Sizeof(charCode)))))
+		charCode = castToUint16(str + (makeUintptrFromUint64(i) * unsafe.Sizeof(charCode)))
 	}
 	return i
 }

pkg/powershell/hostcommand.go

@@ -61,7 +61,7 @@ func (writer *callbackResultsWriter) filloutResults(res uintptr) {
 
 	if writer.objects != nil && len(writer.objects) > 0 {
 		results.count = uint32(len(writer.objects))
-		results.objects = mallocCopyGenericPowerShellObject(&writer.objects[0], uint64(len(writer.objects)))
+		results.objects = mallocCopyArrayGenericPowerShellObject(writer.objects)
 	}
 	_ = memcpyJsonReturnValues(res, results)
 }

pkg/powershell/powershell.go

@@ -115,11 +115,10 @@ func (command psCommand) Invoke() *InvokeResults {
 }
 
 func makePowerShellObjectIndexed(objects uintptr, index uint32) Object {
-	// I don't get why I have to use unsafe.Pointer on C memory
 	var handle nativePowerShell_PowerShellObject
 
 	offset := (uintptr(index) * unsafe.Sizeof(handle))
-	handle = *(*nativePowerShell_PowerShellObject)(unsafe.Pointer(objects + offset))
+	handle = castToPowershellObject(objects + offset)
 	return makePowerShellObject(handle)
 }
 

pkg/powershell/runspacehelpers.go

@@ -136,7 +136,7 @@ var (
 	// intentionally leak loggerCallbackPointer (once per process)
 	// doing this so the callback object will be around for lifetime of process
 	// If it was golang object just marshalled for duration of call, golang garbage collection could move things and we would crash
-	loggerCallbackPointer  uintptr = mallocCopyLogStringHolder(loggerCallbackHolder)
+	loggerCallbackPointer  uintptr = localMallocCopyLogStringHolder(loggerCallbackHolder)
 	commandCallbackPointer uintptr = syscall.NewCallbackCDecl(commandCallback)
 )