upload code

Author: Troublor

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "secp256k1"]
+	path = secp256k1
+	url = git@github.com:Troublor/secp256k1.git

.idea/.gitignore

@@ -0,0 +1,13 @@
+pragma solidity ^0.8.0;
+
+contract BasicStorage {
+  uint a;
+  uint[] b;
+  mapping(uint => uint) c;
+
+  function invoke(uint a_, uint b_, uint ck_, uint cv_) public {
+    a = a_;
+    b.push(b_);
+    c[ck_] = cv_;
+  }
+}

.idea/erebus-redgiant.iml

@@ -0,0 +1,12 @@
+{
+  let a := sload(0)
+  let b := sload(1)
+
+  if eq(a, 0) {
+    sstore(2, 0)
+  }
+
+  if eq(b, 1) {
+    sstore(3, 1)
+  }
+}

.idea/modules.xml

@@ -0,0 +1,7 @@
+{
+    let a := 1
+    let b := sload(a)
+    let b2 := add(b, 2)
+    let c := sload(b2)
+    mstore(b, c)
+}

.idea/vcs.xml

@@ -0,0 +1,8 @@
+{
+    let seed := 9
+    mstore(0, caller())
+    mstore(0x20, seed)
+    let addr := keccak256(0, 0x40)
+    let sdata := sload(addr)
+    sstore(1, sdata)
+}

analysis/__test__/basic_storage.sol

@@ -0,0 +1 @@
+*/

analysis/__test__/criticality_analysis.yul

@@ -0,0 +1,37 @@
+// SPDX-License-Identifier: UNLICENSED
+
+pragma solidity ^0.8.0;
+
+contract Contract {
+  mapping(address => uint) public balances;
+
+  event Transfer(address indexed from, address indexed to, uint value);
+
+  constructor(uint256 initialSupply) {
+    balances[msg.sender] = initialSupply;
+  }
+
+  function balanceOf(address account) public view returns (uint balance) {
+    return balances[account];
+  }
+
+  function transfer(address to, uint amount) public returns (bool success) {
+    return this.transferFrom(msg.sender, to, amount);
+  }
+
+  function transferFrom(
+    address from,
+    address to,
+    uint amount
+  ) public returns (bool success) {
+    require(balances[from] >= amount);
+    balances[from] -= amount;
+    balances[to] += amount;
+    emit Transfer(from, to, amount);
+    return true;
+  }
+
+  function guessWhat(bool guess) public pure {
+    assert(guess);
+  }
+}

analysis/__test__/data_flow_pure_stack.yul

@@ -0,0 +1,8 @@
+package data_flow
+
+type Analyzer interface {
+	NewFlowNode(operation *Operation) FlowNode
+	CheckOperation(operation *Operation) (isSource, isSink bool)
+	SinkTainted(collection *TrackerCollection, flowedValue FlowNode)
+	FlowPolicy() FlowPolicy
+}

analysis/__test__/storage_addressing.yul

@@ -0,0 +1,123 @@
+package data_flow
+
+import (
+	"github.com/Troublor/erebus-redgiant/dyengine/tracers"
+)
+
+type call struct {
+	position tracers.CallPosition
+
+	value FlowNode
+	data  map[uint64]FlowNode
+
+	returnData map[uint64]FlowNode
+	success    FlowNode
+
+	source FlowNode
+}
+
+func newCall(pos tracers.CallPosition) *call {
+	return &call{
+		position:   pos,
+		data:       make(map[uint64]FlowNode),
+		returnData: make(map[uint64]FlowNode),
+	}
+}
+
+func (c *call) setFlowSource(source FlowNode) {
+	c.source = source
+}
+
+func (c *call) matchMsgCall(msgCall *tracers.MsgCall[*Data]) bool {
+	return c.position.Cmp(msgCall.Position) == 0
+}
+
+func (c *call) StoreData(memory *memory, offset, length uint64) {
+	if length == 0 {
+		return
+	}
+	start := memoryGranularity.Regulate(offset)
+	for i := uint64(0); start+i < offset+length; i += memoryGranularity.Uint64() {
+		c.data[i] = memory.mem[start+i]
+	}
+}
+
+func (c *call) StoreReturnData(memory *memory, offset, length uint64) {
+	if length == 0 {
+		return
+	}
+	start := memoryGranularity.Regulate(offset)
+	for i := uint64(0); start+i < offset+length; i += memoryGranularity.Uint64() {
+		c.returnData[i] = memory.mem[start+i]
+	}
+}
+
+func (c *call) GetData(start, length uint64) FlowNodeList {
+	if length == 0 {
+		return nil
+	}
+	var values FlowNodeList
+	for i := memoryGranularity.Regulate(start); i < start+length; i += memoryGranularity.Uint64() {
+		v := c.data[i]
+		if v != UntaintedValue {
+			values = append(values, v)
+		}
+	}
+	if len(values) == 0 && c.source != nil {
+		values = append(values, c.source)
+	}
+	return values
+}
+
+func (c *call) GetValue() FlowNode {
+	return c.value
+}
+
+func (c *call) GetSuccess() FlowNode {
+	if c.success != UntaintedValue {
+		return c.success
+	} else if c.source != nil {
+		return c.source
+	} else {
+		return c.success
+	}
+}
+
+func (c *call) GetReturnData(start, length uint64) FlowNodeList {
+	if length == 0 {
+		return nil
+	}
+	var values FlowNodeList
+	for i := memoryGranularity.Regulate(start); i < start+length; i += memoryGranularity.Uint64() {
+		v := c.returnData[i]
+		if v != UntaintedValue {
+			values = append(values, v)
+		}
+	}
+	if len(values) == 0 && c.source != nil {
+		values = append(values, c.source)
+	}
+	return values
+}
+
+func (c *call) GetAllReturnData() FlowNodeList {
+	var values FlowNodeList
+	for _, v := range c.returnData {
+		if v != UntaintedValue {
+			values = append(values, v)
+		}
+	}
+	if len(values) == 0 && c.source != nil {
+		values = append(values, c.source)
+	}
+	return values
+}
+
+func (c *call) ReturnDataIsTainted(analyzer Analyzer) bool {
+	for _, node := range c.returnData {
+		if node != UntaintedValue && node.From().IsTainted() {
+			return true
+		}
+	}
+	return false
+}

analysis/data_flow/__test__/.gitignore

@@ -0,0 +1,33 @@
+package data_flow
+
+import (
+	"github.com/ethereum/go-ethereum/common"
+)
+
+type chain struct {
+	balances map[common.Address]FlowNode
+	codes    map[common.Address]FlowNode
+}
+
+func newChain() *chain {
+	return &chain{
+		balances: make(map[common.Address]FlowNode),
+		codes:    make(map[common.Address]FlowNode),
+	}
+}
+
+func (c *chain) GetBalance(addr common.Address) FlowNode {
+	return c.balances[addr]
+}
+
+func (c *chain) SetBalance(addr common.Address, node FlowNode) {
+	c.balances[addr] = node
+}
+
+func (c *chain) GetCode(addr common.Address) FlowNode {
+	return c.codes[addr]
+}
+
+func (c *chain) SetCode(addr common.Address, node FlowNode) {
+	c.codes[addr] = node
+}

analysis/data_flow/__test__/contract.sol

@@ -0,0 +1,13 @@
+package data_flow_test
+
+import (
+	"testing"
+
+	. "github.com/onsi/ginkgo/v2"
+	. "github.com/onsi/gomega"
+)
+
+func TestDataFlow(t *testing.T) {
+	RegisterFailHandler(Fail)
+	RunSpecs(t, "DataFlow Suite")
+}