EIP1967-实现可升级智能合约

EIP1967实现可升级的合约(逻辑和数据存储分离)

https://eips.ethereum.org/EIPS/eip-1967

写的很好：https://zhuanlan.zhihu.com/p/551852314

OpenZeppelin的实现： https://github.com/OpenZeppelin/openzeppelin-contracts/tree/master/contracts/proxy

https://docs.openzeppelin.com/upgrades-plugins/1.x/proxies

解决upgrade-safe
https://docs.openzeppelin.com/upgrades-plugins/1.x/faq#what-does-it-mean-for-a-contract-to-be-upgrade-safe

通过使用逻辑处理与存储分离的模式，来实现智能合约升级。

通过以下代码进行理解

contract Proxy {
	mapping(address => uint) private balances; // 余额

	address private impl;

	function upgradeTo(address _addr) {
		impl = _addr;
	}

    // 当调用的代理
	fallback() external payable virtual {
        _fallback();
    }
    function _fallback() internal virtual {
        _beforeFallback();
        _delegate(_implementation());
    }


    // 调用
    function _delegate(address implementation) internal virtual {
        assembly {
            // Copy msg.data. We take full control of memory in this inline assembly
            // block because it will not return to Solidity code. We overwrite the
            // Solidity scratch pad at memory position 0.
            calldatacopy(0, 0, calldatasize())

            // Call the implementation.
            // out and outsize are 0 because we don't know the size yet.
            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)

            // Copy the returned data.
            returndatacopy(0, 0, returndatasize())

            switch result
            // delegatecall returns 0 on error.
            case 0 {
                revert(0, returndatasize())
            }
            default {
                return(0, returndatasize())
            }
        }
    }
}

部署


const { ethers, upgrades } = require("hardhat");

async function main() {

    //    acc  = ethers.getSigners()
    const [owner] = await ethers.getSigners();

    // Deploying
    const sbt = await ethers.getContractFactory("SBT");
    const instance = await upgrades.deployProxy(
        sbt,
        [
            "Soulbound Token",
            "SBT",
            owner.address,
        ],
        {
            initializer: "initialize",
            kind: "transparent",
            unsafeAllow: ['delegatecall'] // 遇到unsafe upgrade错误，可以强行使用
        }
    );

    let ret = await instance.deployed();
    console.log(ret)

//   await upgradeProxy(proxyAddress, implementationFactory, { unsafeAllow: ['delegatecall'] });

//   Upgrading
//   const BoxV2 = await ethers.getContractFactory("BoxV2");
//   const upgraded = await upgrades.upgradeProxy(instance.address, BoxV2);
}

main();

2022年9~12月技术学习

FISCO BCOS (9.24考试)
Rust (aptos, sui, solana)
Move智能合约(starcoin, aptos, sui)
layer2(Polygon, Optimism, ZK-EVM)
Ethereum(2.0)
Js(Hardhat, Ether.js)

深度解析Optimism窃取事件

本文在这篇文章深度解析 Optimism窃取事件：Layer2 网络合约部署重放攻击加以梳理，并配有详细的示例代码，示例代码会放在github上。

起因

为了简化，就用甲方乙代替公司名吧。甲方（optimism）要乙方（Wintermute）帮忙搞事情，因为乙在layer1玩得很溜，甲方想在自己的layer2也玩起来。

于是，乙方爽快地答应了，给了一个收币地址给甲方说：“你忘这个地址上转币吧，其他事情我这边搞定。”甲方很开心地向乙方提供的收币地址转了2000万个OP币，乙方却说没有收到。一查才发现，乙方提供的是layer1的地址，而甲方转的是layer2的地址，虽然地址长得一样，但是此地址在layer2上尚未被创建（没有创建也可以转账进去）。

那该怎么办呢？两边的技术人员一看说，这是个黑洞地址，现在没有人能转走里面的币，只要操作一波是可以找回那些币的，不过现在是五一假期，大家都在夏威夷独家呢，过了五一节再说吧（开玩笑）。黑客可没有五一，立即行动，搞走了里面的币。甲乙双方尴尬了。

分析

黑客是做到的呢？思路很简单，只要2步：

在layer2上创建乙方的收币地址（是合约地址）
搞到乙方的收币地址的所有权（控制权），因为地址是合约地址，而且是个proxy合约，即代理合约。
转移资金

Layer1

Gnosis Safe Proxy Factory（以下统称合约A): 0x76e2cfc1f5fa8f6a5b3fc4c8f4788f0116861f9b
Wintermute proxy(以下统称合约B): 0x4f3a120E72C76c22ae802D129F599BFDbc31cb81

其中合约A由此交易创建:https://etherscan.io/tx/0x75a42f240d229518979199f56cd7c82e4fc1f1a20ad9a4864c635354b4a34261
这笔交易的发起地址是：0x1aa7451dd11b8cb16ac089ed7fe05efa00100a6a

合约B由此交易创建：https://etherscan.io/tx/0xd705178d68551a6a6f65ca74363264b32150857a26dd62c27f3f96b8ec69ca01#eventlog

这笔交易的发起者不重要，重要的是调用ProxyCreation传入的参数，0x76e2cfc1f5fa8f6a5b3fc4c8f4788f0116861f9b，这个地址就是合约A

Layer2

合约地址A：0x76e2cfc1f5fa8f6a5b3fc4c8f4788f0116861f9b
合约地址B：0x4f3a120e72c76c22ae802d129f599bfdbc31cb81

https://etherscan.io/txs?a=0x1aa7451dd11b8cb16ac089ed7fe05efa00100a6a

⭐ 第1步：如何在layer2创建处合约地址A？

因为layer1上创建合约A的交易，没有使用EIP155,所以可以，将此笔交易进行重放。

重放layer1上创建合约A的交易：https://optimistic.etherscan.io/tx/0x75a42f240d229518979199f56cd7c82e4fc1f1a20ad9a4864c635354b4a34261
，保证发送笔交易时nonce与layer创建合约A时一样即可。

如何重放？可以使用RPC sendRawTransaction将交易data发到layer2链上即可，当然要保证账户有余额

⭐ 第2步：如何在layer2创建处合约地址B？

合约地址生成原理: Hash(caller, nonce_of_caller)

普通地址的nonce记录的交易次数，合约地址的nonce值是合约地址创建合约数量。nonce值可以以太坊的JSON RPC接口获取

例如获取当前的nonce值

curl https://mainnet.infura.io/v3/8a264f274fd94de48eb290d35db030ab \
-X POST \
-H "Content-Type: application/json" \
-d \
'{
    "jsonrpc": "2.0",
    "method": "eth_getTransactionCount",
    "params": [
        "0x76e2cfc1f5fa8f6a5b3fc4c8f4788f0116861f9b",
        "latest" 
    ],
    "id": 1
}'

输出

1	{"jsonrpc":"2.0","id":1,"result":"0x89a7"}

其中，0x89a7是35239，黑客是不是要创建这么多合约呢？其实不用，因为layer1上的合约B是2020年创建的，那时候合约A的nonce肯定没有这么大。有没有什么办法可以获取到那笔创建合约B时，合约A的准确的nonce值呢？有的！etherscan就记录了state的转换：https://etherscan.io/tx/0xd705178d68551a6a6f65ca74363264b32150857a26dd62c27f3f96b8ec69ca01#statechange

nonce从8884增加到了8885，也就说，我们要得到的nonce值就是8884！

当然也可以使用以下代码找到nonce值：

const Web3 = require("web3");
const RLP = require("rlp");

const account = "0x76e2cfc1f5fa8f6a5b3fc4c8f4788f0116861f9b";

for (let nonce = 0; nonce < 0xffffffff; nonce++){
    let e = RLP.encode([account, nonce] );
    const nonceHash = Web3.utils.sha3(Buffer.from(e));
    const targetAddress = '0x'+ nonceHash.substring(26)
    if(targetAddress === '0x4f3a120e72c76c22ae802d129f599bfdbc31cb81') {
        console.log(nonce)
        break
    }
}

输出结果是:8884

黑客创建了一个攻击合约（以下称作合约C）：0xE7145dd6287AE53326347f3A6694fCf2954bcD8A

只要调用合约A不停地创建合约，当nonce与layer1创建合约B那笔交易的nonce相同，就可以在layer2创建出合约地址B。

黑客在layer2上创建合约B地址的交易log，在135位置：https://optimistic.etherscan.io/tx/0x00a3da68f0f6a69cb067f09c3f7e741a01636cbc27a84c603b468f65271d415b#eventlog

黑客是如何将合约B中的masterCopy设置为自己的攻击合约地址的？

在区块浏览器查不到合约B的构造参数，但是我们看合约A的代码 https://optimistic.etherscan.io/address/0x76e2cfc1f5fa8f6a5b3fc4c8f4788f0116861f9b#code：


/// @dev Allows to create new proxy contact and execute a message call to the new proxy within one transaction.
/// @param masterCopy Address of master copy.
/// @param data Payload for message call sent to new proxy contract.
function createProxy(address masterCopy, bytes memory data)
    public
    returns (Proxy proxy)
{
    proxy = new Proxy(masterCopy);
    if (data.length > 0)
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            if eq(call(gas, proxy, 0, add(data, 0x20), mload(data), 0, 0), 0) { revert(0, 0) }
        }
    emit ProxyCreation(proxy);
}

只要在调用createProxy时将masterCopy设置为黑客自己的攻击合约地址即可，data为空，这样即可。

⭐ 第3步：如何转移合约B中的金额？

黑客转移合约B上的1000000个OP的交易：https://optimistic.etherscan.io/tx/0x230e17117986f0dc7259db824de1d00c6cf455c925c0c8c6b89bf0b6756a7b7e

查看内部交易：https://optimistic.etherscan.io/tx/0x230e17117986f0dc7259db824de1d00c6cf455c925c0c8c6b89bf0b6756a7b7e#internal

其中 0xE7145dd6287AE53326347f3A6694fCf2954bcD8A 就是黑客攻击合约

交易的inputData

0xad8d5f480000000000000000000000004200000000000000000000000000000000000042000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000044a9059cbb00000000000000000000000060b28637879b5a09d21b68040020ffbf7dba510700000000000000000000000000000000000000000000d3c21bcecceda100000000000000000000000000000000000000000000000000000000000000

其中 0xad8d5f48: 是exec(address,bytes,uint256)的签名

我们再看看layer1上合约B的源码：


contract Proxy {

    // masterCopy always needs to be first declared variable, to ensure that it is at the same location in the contracts to which calls are delegated.
    // To reduce deployment costs this variable is internal and needs to be retrieved via `getStorageAt`
    address internal masterCopy;

    /// @dev Constructor function sets address of master copy contract.
    /// @param _masterCopy Master copy address.
    constructor(address _masterCopy)
        public
    {
        require(_masterCopy != address(0), "Invalid master copy address provided");
        masterCopy = _masterCopy;
    }

    /// @dev Fallback function forwards all transactions and returns all received return data.
    function ()
        external
        payable
    {
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let masterCopy := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)
            // 0xa619486e == keccak("masterCopy()"). The value is right padded to 32-bytes with 0s
            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {
                mstore(0, masterCopy)
                return(0, 0x20)
            }
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas, masterCopy, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if eq(success, 0) { revert(0, returndatasize()) }
            return(0, returndatasize())
        }
    }
}

问题来了，并没有发现exec函数！这是怎么回事呢？

我们注意到，函数function () external payable是fallback函数，也就是说当调用时没有匹配到函数时，会进入fallback函数。

因为masterCopy在创建合约B时，就已经设置为黑客自己的攻击合约地址0xE7145dd6287AE53326347f3A6694fCf2954bcD8A。

如此一来，代码中的delegatecall调用黑客自己的攻击合约，然后在攻击合约中执行OP合约(0x4200000000000000000000000000000000000042)的ERC20的transfer操作，又因为使用的是delegatecall，msg.sender就是合约B的地址，即(0x4f3a120e72c76c22ae802d129f599bfdbc31cb81)，所以，调用transfer时，扣除的msg.sender的OP代币余额，这样，就可以转移了OP代币。

我们再验证这个合约B的“转发”功能，

其中0x8da5cb5b是函数owner()的签名。合约B0x4f3a120e72c76c22ae802d129f599bfdbc31cb81将请求转发到黑客的攻击合约，如下图：

模拟转移代币

为了更加深入理解，我们编写一个测试合约，来模拟黑客转移代币的操作。

我们把proxy的代码复制过来；
然后编写一个Erc20合约模拟OP代币合约，秩序实现一个简单的transfer操作；
再编写一个Hacker合约，模拟黑客的攻击合约

代码如下：

pragma solidity ^0.4.26;

contract Proxy {

    address internal masterCopy;
    constructor(address _masterCopy)
        public
    {
        require(_masterCopy != address(0), "Invalid master copy address provided");
        masterCopy = _masterCopy;
    }

    /// @dev Fallback function forwards all transactions and returns all received return data.
    function ()
        external
        payable
    {
        // solium-disable-next-line security/no-inline-assembly
        assembly {
            let masterCopy := and(sload(0), 0xffffffffffffffffffffffffffffffffffffffff)
            // 0xa619486e == keccak("masterCopy()"). The value is right padded to 32-bytes with 0s
            if eq(calldataload(0), 0xa619486e00000000000000000000000000000000000000000000000000000000) {
                mstore(0, masterCopy)
                return(0, 0x20)
            }
            calldatacopy(0, 0, calldatasize())
            let success := delegatecall(gas, masterCopy, 0, calldatasize(), 0, 0)
            returndatacopy(0, 0, returndatasize())
            if eq(success, 0) { revert(0, returndatasize()) }
            return(0, returndatasize())
        }
    }
}


contract Erc20 {
    address public sender;
    // 为了方便查看结果，我们输出一个log
    event Transfer(address indexed from, address indexed to, uint256 value);
    function transfer(address to, uint256 amount) external returns (bool) {
        sender = msg.sender;
        // 略，其他操作，从msg.sender余额扣除，增加to的余额
        emit Transfer(msg.sender, to, amount);
        return true;
    }
}


contract Hacker {
    event Ok(address,bytes,uint256);
    event Failed(bool);

    function exec(address addr, bytes data, uint256 amount)  public payable returns(bool){
        Erc20 erc20 = Erc20(addr);
        address to = 0xFFfFfFffFFfffFFfFFfFFFFFffFFFffffFfFFFfF;
        assembly {
            to := mload(add(data,20)) // 将data转为地址
        }
        bool success = erc20.transfer(to, amount);
        if(success) {
            // 为了方便查看结果，我们输出一个log
            emit Ok(addr, data, amount);
            return true;
        } else {
            // 为了方便查看结果，我们输出一个log
            emit Failed(false);
            return false;
        }
    }   

}

具体部署步骤:

部署Erc20合约
部署Hacker合约
部署proxy合约，构造参数将masterCopy地址设置Hacker合约地址即可

为了获得proxy的调用data，我们这里先直接调用Hacker的exec函数，这样就可以获得完整的input data

0xad8d5f4800000000000000000000000032f99155646d147b8a4846470b64a96dd9cba4140000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000115c000000000000000000000000000000000000000000000000000000000000001460b28637879b5a09d21b68040020ffbf7dba5107000000000000000000000000

我们将此input data 填入proxy的CALLDATA，就可以调用proxy的fallback函数，运行结果如下：

至此，我们这个分析流程结束。

总结

山外有山，人外有人。应该向黑客学习，学习他的好的一面，比如，技术方面、耐心。

示例代码链接：https://github.com/youngqqcn/optimism-attack-analysis

github非常有价值的项目1

2022-06-08

技术

PaddleOCR

仓库链接：https://github.com/PaddlePaddle/PaddleOCR
说明：基于深度学习的OCR库

Web-Dev-For-Beginners

仓库链接：https://github.com/microsoft/Web-Dev-For-Beginners
说明：微软出品的零基础学习网站开发

百万富翁的思维密码

2022-05-29

读书

第一部分：财富蓝图

金钱有“外部”规律也有“内部”规律。外部规律包括商业知识、资金管理、投资策略等等。
事实是，你的性格、你的思维方式，以及你的信仰是决定你成功程度的关键。
大多数人都没有内在的内里创造并持有大笔资金，无法应对与金钱有关的与日俱增的挑战。
如果想要改变果实，你就得先改变它的根；如果要改变有形的东西，首先从无形的东西着手。
这个世界上你看不见的东西的能量远大于你能看到的东西的能量。
你没有办法改变今天已经悬挂在枝头的果实，但你可以改变明天的果实。而要做到这一点，你得挖开地面，增强根的力量。
金钱是结果，财富是结果，健康是结果，疾病是结果，你的体重也是结果，我们生活在因果世界之中。
你潜意识中的设定决定了你的思维。你的思想决定了你的决策，你的决策决定了你的行为，这些因素最终决定了结果。
如果你获得金钱或成功的动机，从根子上讲是一些无益的因素，诸如恐惧、愤怒，或需要“证明”你自己，那么你永远都得不到快乐。
恐惧不只是一种问题，而且是一种习惯。因此，赚钱多只能改变我们的恐惧方式。
实际上就，和担心赚不到钱相比，人们更担心赚到钱以后又会失去它。
夫妻因钱的问题而争吵，其背后最大的原因不是金钱本身，而是他们的“蓝图”不匹配。
你可以尝试仍和想尝试的东西，你可以增长自己在上商务、市场、销售、谈判、管理等方面的知识，你可以成为房地产或股票市场的专家。
你的收入只能按照你所期望的程度增长。

第二部分：财富档案

富人的17条的思考和行动方法

思想决定情感，情感决定行动，行动决定结果。
你可以选择有利于自己的幸福与成功的思维方式，而不是相反。
中产者通常兼有富人和穷人的思维方式。
人们事实上有两种习惯：有作为的习惯和无作为的习惯。

财富档案1：富人认为：我创造生活；穷人认为：我遭遇生活。

在需要钱的地方，金钱极为重要，而在不需要它的地方，它就显得微不足道了。
吸引力法则认为“同类相吸”，即当你抱怨的时候，实际上你就把“不公正之类的东西”吸入了自己的生活。
你不得不确保自己远离爱抱怨的人。如果万不得已和他们在一起，得确保打上上一把金属伞防御，不然他们胡说八道的东西也会感染到你。
消极的能力可以传染。
没有哪个富人是真正的受害者。

财富档案2：富人玩金钱游戏是为了获胜；穷人玩金钱游戏是为了不输。

如果你的目标是为了过得舒适，那么你是永远不会成为有钱人的。但如果你的目标是想变成有钱人，那么你的生活就会过得极为舒适。

财富档案3：富人以行动致富；穷人靠梦想致富。

大多数人不能得到自己想要的东西，首要原因是他们不知道自己到底想要什么。
如果你没有真正全身心地投入到创造财富的事业当中，你可能就不会成功。

财富档案4：富人大处着眼；穷人小处考虑。

你获得的报酬取决于你给市场带来的价值比例。
大多数人都选择小打小闹。为什么呢？首先他们担心，他们对失败害怕得要死，更有甚者，他们甚至害怕成功。
创业者的定义：通过为别人解决问题而获利的人。

财富档案5：富人关注机会；穷人关注困难。

穷人总是在瞻前顾后的基础上做选择。在任何情况下，他们总是考虑哪些地方有问题或有可能出问题。他们的定式思维是“如果不起作用怎么办？”或经常是“这不会起作用的”。
通常来讲，回报越多，风险越大。因为总是能看到机会，所以有钱人情愿去冒险。他们相信，即使情况再糟，他们也能把自己的钱赚回来。
有钱人冒险是建立在调查研究的基础上的，这意味着他们做研究，开动脑筋，在可靠的信息和事实的基础上作出决策。有钱人是不是要倾其毕生去做调查研究呢？答案是否定的。他们花尽可能短的时间了解情况，然后决定取舍。
运气的因素和致富是有一定联系的，或者，由于这种原因，它也和取得成功有一定联系。
要想成功地赚钱，你得做点什么，投资点什么，或开办什么实业。如果你做了，这是运气，或者也是上苍以更为庞大的力量来奇迹般地支持你。
有钱人关注他们想要的东西，而穷人关注他们不需要的东西。需要再次说明的是，这符合一个普遍原则：“事态会随着你关注的方向发展。”
你关注问题的视野决定了你在生活中能发现什么。关注机会，你就能看到机会；关注困难，你看到的就是困难。
如果想要致富，就把精力放在如何赚钱、守住你赚的钱以及如何投资上。
认为自己可以预知未来是愚蠢的想法：认为可以胸有成竹地应对某天可能发生的情况，并做好自我保护是痴人说梦。你知道吗，宇宙中根本没有真正的直线？生活也不会沿着真正的直线向前发展，它就像蜿蜒前行的河流。多半情况下，你只能看到它拐弯的地方，只有到了这个拐弯，你才能看到前方更远的地方。
如果你真想要了解这个行业，就融入到这个行业中区。你不可能一天的功夫就把它了解得一清二楚。你可以走进“走廊”，找一份这个领域的工作，这样你就真正可以走进“走廊”。扫地刷盘子要比你站在旁观者的角度做上十年的研究了解得多。
有钱人说做就做，他们相信一旦涉足某件事情，他们可以根据形式作出明智的选择，在自己事业的道路上不断修正、调整。

财富档案6：富人羡慕别的富人或成功人士；穷人仇视富人和成功人士。

祝福你想得到的东西。——胡纳哲学

财富档案7：富人喜欢和积极、成功的人交往；穷人喜欢和消极、失败的人交往。

创造财富最快捷、最容易的办法就是学习那些掌握财富的有钱人是如何赚钱的。如果你采取和他们一样的行动，保持和他们一样的心态，那么你就很有可能取得和他们一样的结果。
和有钱人交谈，学习他们是如何思考的，并和他们交换联系方式。如果我们在其他方面有共同语言，那么我们会成为私人好友。
首先，不必费心试着去改变那些消极的人，试图让他们回心转意。这不是你的工作。你的工作是把你所学的东西用于提高自己，改善自己的生活。做一个榜样，做一个成功者，做一个幸福的人，然后或许——我这里强调的是或许——他们将会在你身上看到希望，也想自己做点什么。接下来要说的是，能量具有传染的特性；黑暗会被光明驱散。可能有些人，当身边充满光明时还在力图停留在“黑暗”中。你的工作仅仅是让自己尽可能做到最好。如果他们真想打听你成功的秘诀的话，告诉他们就是了。
我个人永远不会和一个不求进取、阻碍我学习和成长的欲望的人生活，不管从个人情感、精神还是经济上都是如此。
大多数人所赚的钱与他们最亲密的朋友的收入相比，波动在20%以内。
我也特别注意远离有害环境，我找不出任何理由让自己受到有毒能量的感染。这些有毒能量包括争吵、说长道短、陷害等等；同时，我认为还包括观看“不动脑筋”的电视节目，除非你专门用它来作为放松方式，而不单单是娱乐。

财富档案8：富人情愿提升自己和自身的价值；穷人消极地看待销售和提升行为。

财富档案9：富人比自己遇到的困难更强大；穷人比自己遇到的困难更弱小。

财富的增长程度与你的行动成正比。你的目标是使自己强大起来，强大到能够克服任何阻碍你创造财富、守住财富的困难。
把你想成一个容纳财富的容器，如果容器太小，而钱又太多，那么将会发生什么呢？结果当然是你将失去这些钱，多余的钱会从你的容器中溢出来，你不可能拥有超出你的容量的钱。因此，你必须成为一个大容器，这样你就不仅能容纳财富，还能吸引更多的财富。
富人是优秀的接受者；穷人是拙劣的接受者。
如果你说自己有价值，你就有；如果你说自己没有价值，你就没有。无论是有还是么有，你都会生活在自己设定的故事中。
穷人唯一拥有的东西就是贫穷。
做任何事情的方式就是你做每一件事情的方式。
富人选择以结果赚钱；穷人选择用时间赚钱。
穷人拿时间赚钱，而这一方式的问题是，时间是有限的。
如果选择拿时间赚取报酬，那么就是在扼杀自己获得财富的机会。

财富档案12：富人想“两全其美”；穷人想“二择其一”

许多人都认为钱和幸福是互相排斥的，我再次申明，这只不过是“穷人”程序化的结果罢了。

财富档案13：富人关心他们的净资产；穷人在乎他们的工资。

真正的财富指的是净资产，不是工资收入。
影响净资产的4个因素：收入、储蓄、投资、简朴生活。
富人会花更多的时间和精力去学习投资和理财，他们得意于自己是一名优秀的投资者。
“简朴”，很少人意识到它的重要性，通过减少你的生活成本，增加你的储蓄，用来投资的资金也就增加了。

财富档案14：富人善于理财；穷人理财无方。

如果处理不好你现在拥有的东西，就别想得到更多。
养成理财习惯比拥有金钱更重要。

财富档案15：富人让钱为其效力；穷人为钱而卖力。

努力工作赚钱，对于富人来说，只是暂时的；但对于穷人来说，却是永久的。
金钱游戏的目标是“从此以后永远不在工作，除非你自己选择要去工作”，而且，如果你要工作的话，你是“自由选择工作而不是必须工作”。
我再强调一遍，让钱为你效力而不是你为钱卖力，那意味着你要节约资金用来投资，而不是把花钱当成天职。有趣的是“富人有很多钱却花得很少，穷人没几个钱却花得很多”
长期和短期对比就是：穷人工作赚钱是为了今天的生活；富人工作赚钱是用来投资，为将来的生活储存资金。
富人购买资产，都是能增值的东西；穷人购买的消费品，都是肯定会贬值的东西；

财富档案16：富人勇往直前；穷人畏首畏尾。

安逸的代价太高，你生活得越安逸，就越不敢去冒险。
再强调一次，真正能让你成长的是当你感觉不容易的时候。
幸福从来都不是来自于平淡无光的生活，也从来不是来自充满假设的幻想。幸福是从我们自然成长及开发我们潜能的过程中产生的。
要获得幸福和成功，最重要的技能是训练和管理你自己的思想。

财富档案17：富人在不断学习中成长；穷人则认为自己无所不知。

如果你没有时间去做你想做而且应该做的事情，那么你会被时间所淘汰；如果你没有钱去学习如何才能成功，那你就会比别人更需要钱。说“我没钱”并不能让一切改观。你什么时候有钱呢？从今天开始的两年或五年后会有什么不同呢？答案很简单：没有任何改变！而且那个时候，你还是会说同样的话。
变富并保持富有的最快的方法就是提升自己！即让自己成为一个“成功”人士。再说一次，你的外在世界只不过是你内心世界的反映罢了。
如果你不从内心提升自己，也许你以某种方式赚到了很多钱，那最多也就是一次意外而已，很快你就会失去它。但是如果你由内而外都是成功人士的话，你不仅能赚钱，还能存钱，让钱增值，最重要的是，你会真正地快乐。
富人的成功顺序：做人、做事、有钱
穷人及中产者认为成功的顺序是：有钱、做事、做人
还有一些只有富人才知道的东西：创造财富的目标，最主要的不是拥有很多钱，而是帮助提升自己，成为最优秀的人。其实，那就是你的总目标，让自己成“人”。
富人不仅坚持学习，而且还确保自己向那些已经到达他们期望的目标的人学习。
富人会采纳比他们富有者的建议，穷人则听取朋友们的建议，而那些朋友跟他一样一无所有。

yqq's blog