跳至主要内容

记一次混淆算法逆向分析

原文来自乌云，备份地址

0x00 前言

小弟最近整理之前的资料，偶然发现半年前的混淆对抗研究以及一道CTF练习题目，故分享以作记录。限于水平，难免会有疏漏或者错误之处，望各位读者批评指正。

0x01 基本分析

jeb打开文件，找到方法校验方法。逻辑很简单，校验函数既是Native函数check.
public native boolean check(String arg1) {
}

protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    this.setContentView(2130903040);
    this.inputCode = this.findViewById(2131099648);
    this.btn_submit = this.findViewById(2131099649);
    this.btn_submit.setOnClickListener(new View$OnClickListener() {
        public void onClick(View v) {
            if(MainActivity.this.check(MainActivity.this.inputCode.getText().toString())) {
                MainActivity.this.startActivity(new Intent(MainActivity.this, ResultActivity.class));
            }
            else {
                Toast.makeText(MainActivity.this.getApplicationContext(), "Incorrect Password!", 
                        0).show();
            }
        }
    });
}
直接使用IDA默认Loader打开直接崩溃，存在畸形ELF文件对抗，使用自定义LOADER加载，也是然并卵的节奏。
使用Tracer动态打印check函数地址，挂起进程，dump出对应的代码段加载到IDA，找到check函数。
seg000:4561E4E8 check
seg000:4561E4E8                 LDR             PC, =sub_4561E4EC
seg000:4561E4E8 ; End of function check
seg000:4561E4E8
seg000:4561E4EC ; =============== S U B R O U T I N E   seg000:4561E4EC sub_4561E4EC                            ; CODE XREF: check j
seg000:4561E4EC                                         ; DATA XREF:    seg000:4561E4EC                 STMFD           SP!, {R0-R12,LR}
seg000:4561E4F0                 LDR             R0, =6
seg000:4561E4F4                 B               loc_4561E444
通过分析发现，其实为一个汇编stub，通过此stub跳到真正的check函数。
seg013:80A0135C sub_80A0135C                            ; DATA XREF: seg013:80A13F98 o
seg013:80A0135C                 B               sub_80A065B8
seg013:80A0135C ; End of function sub_80A0135C
seg013:80A01360
seg013:80A01360 ; =============== S U B R O U T I N E   seg013:80A01360 ; Attributes: thunk
seg013:80A01360
seg013:80A01360 sub_80A01360                            ; DATA XREF: sub_80A065C4+C o
seg013:80A01360                 B               sub_80A065F8
seg013:80A01360 ; End of function sub_80A01360
seg013:80A01364 ; =============== S U B R O U T I N E   seg013:80A01364 ; Attributes: thunk
seg013:80A01364
seg013:80A01364 sub_80A01364                            ; CODE XREF: sub_80A06620 j
seg013:80A01364                 B               sub_80A0663C
seg013:80A01364 ; End of function sub_80A01364
以80A0135C(B sub_80A065B8)为例子，跟进sub_80A065B8，可以看到如下指令：
// 0x80A0135C
seg013:80A065B8                 BEQ             loc_80A0658C
seg013:80A065BC                 BNE             loc_80A0658C

seg013:80A0658C                 STMFD           SP!, {R3-R8,R10,LR} 真实指令
seg013:80A06590                 STMFD           SP!, {R8,LR}
seg013:80A06594                 LDR             R8, loc_80A065A4
seg013:80A06598                 LDR             R8, loc_80A065A8
seg013:80A0659C                 LDR             R8, loc_80A065AC
seg013:80A065A0                 LDR             R8, locret_80A065B0
seg013:80A065A4                 LDR             R8, =(sub_80A065C4 - 0x80A065B0)
seg013:80A065A8                 ADD             R8, PC, R8 ; sub_80A065C4
seg013:80A065AC                 STR             R8, [SP,#4]
seg013:80A065B0                 LDMFD           SP!, {R8,PC}

seg013:80A065C4                 STMFD           SP!, {R8,LR}
seg013:80A065C8                 LDR             R8, =0xFFFFAD25
seg013:80A065CC                 EOR             R8, R8, #0xAD
seg013:80A065D0                 ADD             R8, PC, R8 ; loc_80A01360 //返回到80A01360
seg013:80A065D4                 STR             R8, [SP,#8+var_4]
seg013:80A065D8                 LDMFD           SP!, {R8,PC}
通过分析可以得到真实指令(STMFD SP!, {R3-R8,R10,LR})，其余指令为混淆指令，最终返回到下一条B即80A01360(B sub_80A065F8)指令。通过分析其他B指令，可以得到类似的混淆指令中夹在一条真实指令，只是存在多种混淆的方式。 至此，我们可以得到此混淆的思路：执行"一个B指令"即一条真实的指令，混淆抽象为:
  • 执行前跳转混淆
  • 真实指令
  • 执行后跳转混淆
不难发现，如果仅仅靠一条一条的寻找真实指令，是非常费时费力的。由于执行前后都存在多种模式的混淆，但总的模式是有限的，那么通过提取指令特征匹配即可以自动化实现去混淆，找出真实指令。

0x02 基于指令特征匹配对抗混淆

通过分析找到所有的混淆模式，最后大概几种。限于篇幅，列举一些做说明
// 0x80A0135C
seg013:80A065B8                 BEQ             loc_80A0658C
seg013:80A065BC                 BNE             loc_80A0658C

seg013:80A0658C                 STMFD           SP!, {R3-R8,R10,LR} 真实指令

seg013:80A06590                 STMFD           SP!, {R8,LR}
seg013:80A06594                 LDR             R8, loc_80A065A4
seg013:80A06598                 LDR             R8, loc_80A065A8
seg013:80A0659C                 LDR             R8, loc_80A065AC
seg013:80A065A0                 LDR             R8, locret_80A065B0
seg013:80A065A4                 LDR             R8, =(sub_80A065C4 - 0x80A065B0)
seg013:80A065A8                 ADD             R8, PC, R8 ; sub_80A065C4
seg013:80A065AC                 STR             R8, [SP,#4]
seg013:80A065B0                 LDMFD           SP!, {R8,PC}

seg013:80A065C4                 STMFD           SP!, {R8,LR}
seg013:80A065C8                 LDR             R8, =0xFFFFAD25
seg013:80A065CC                 EOR             R8, R8, #0xAD
seg013:80A065D0                 ADD             R8, PC, R8 ; loc_80A01360
seg013:80A065D4                 STR             R8, [SP,#8+var_4]
seg013:80A065D8                 LDMFD           SP!, {R8,PC}
执行前混淆：B(连续两条条件完全相反的指令) next_jmp 执行后混淆：这里有两组STMFD--LDMFD构成的跳转stub,但其是为一种模式。那如何计算next_jmp呢？这里我采用取巧的方式，通过从LDMFD所在地址反向找到ADD指令，得到";loc_80a01360"，再解析出地址80a01360。当然，存在多种prefix，需要作简单处理获取地址。
def prefix_match(str):
    pattern = ['sub_', 'loc_', 'unk_', 'locret_']
    for prefix in pattern:
        if str.find(prefix) > -1:
            substr = str[str.find(prefix) + len(prefix):]
            return string.atoi(substr, 16)
    return 0xffffffff;
真实指令：通过解析跳转遍历完整个混淆后，通过堆栈平衡原理，提取出真实指令。以上述分析为例，遍历回到下一条指令80a01360后，对指令进行分组即(B)(STMFD SP!, {R3-R8,R10,LR})(STMFD-LDMFD)(STMFD-LDMFD)，非常容易获取真实指令。实现时，可将分组过程可融入到指令的遍历即可。
再接着看另一组混淆，以80A01360(B sub_80A065F8)为例。
// 0x80A01360
seg013:80A065F8                 STMFD           SP!, {R0,LR}
seg013:80A065FC                 LDR             R0, loc_80A0660C
seg013:80A06600                 LDR             R0, loc_80A06610
seg013:80A06604                 LDR             R0, loc_80A06614
seg013:80A06608                 LDR             R0, locret_80A06618
seg013:80A0660C                 LDR             R0, =(loc_80A065E0 - 0x80A06618)
seg013:80A06610                 ADD             R0, PC, R0 ; loc_80A065E0
seg013:80A06614                 STR             R0, [SP,#4]
seg013:80A06618
seg013:80A06618                 LDMFD           SP!, {R0,PC}

seg013:80A065E0                 LDR             R3, [R0] //真实指令

seg013:80A065E4                 STMFD           SP!, {R0,LR}
seg013:80A065E8                 MOV             LR, PC
seg013:80A065EC                 BL              loc_80A065F0
seg013:80A065F0
seg013:80A065F0 loc_80A065F0                            ; CODE XREF: seg013:80A065EC j
seg013:80A065F0                 LDMFD           SP!, {R0,LR}

seg013:80A065F4                 B               sub_80A06620

seg013:80A06620                 B               sub_80A01364
执行前混淆：STMFD-LDMFD跳转到loc_80A065E0。获取next_jmp和上述一致。
执行后混淆：通过STMFD-LDMFD和两次B直接跳转返回到下一条B指令地址sub_80A01364。
真实指令：和上述类似，遍历混淆指令时，对指令进行分组(STMFD-LDMFD)、(LDR R3, [R0])、(B)、(B)。易获取真实指令(LDR R3, [R0])。
通过上述方法，大概分析20个多有的B指令即可找到所有的混淆模式，总的来说混淆的模式是有限的。
通过编写IDAPython脚本，即可实现自动打印真实指令。
0x80a0135c            PUSH            {r3, r4, r5, r6, r7, r8, sl, lr}
0x80a01360            LDR             r3, [r0]
0x80a01364            MOV             r1, r2
0x80a01368            MOV             r6, r2
0x80a0136c            LDR             r3, [r3, #0x2a4]
0x80a01370            MOV             r2, #0
0x80a01374            MOV             r4, r0
0x80a01378            BLX             r3
0x80a0137c            MOV             r7, r0
但存在问题，当IDA并没有识别出指令时，无法通过GetMnem等API获取信息。
p1
由于混淆对IDA指令识别的影响，致使IDA无法自动将指令反汇编出来。可能已经有读者意识到，遇到这种情况直接调用MakeCode将数据转化为指令即可。然而，实际使用MakeCode自动处理时，并不能完成手动按'C'识别指令的功能。那么，是否遇到这种情况后，就手动去完成指令反汇编呢？答案是否定的。由于存在很多这种情况，手动转化也很费时(测试环境IDA6.8)。
到这里可以看到，单纯依靠简单的字符串匹配比较的方法，并不能完全满足自动化提取指令对抗混淆的需求。

0x03 基于指令解析执行对抗混淆

通过上述分析，由于IDA存在无法自动反汇编一部分opcode数据，故单纯依靠IDAPython是无法满足指令解析指令的需求的。为了实现对指令的解析，可采用两种途径：
  1. 对照arm汇编手册，编写常见的opcode解析脚本。以笔者的经验，这部分内容是比较耗时的。
  2. 引入现有的反汇编引擎，且这种反汇编引擎具备对指令的想尽分析的能力。这里，我选用Capstone。
Capstone是一款支持多种架构的反汇编引擎，支持对汇编指令粗略和详细的分析，支持多种语言。当然，Capstone还有很多其他优点，这里就不赘述了。
3.1 ARM处理器模拟
可能有读者马上会问，模拟arm处理器执行不又是一大工程呢。的确，完全模拟确实包含许多工作量。但结合此混淆的一些特性，整个模拟执行可简化许多。
首先，此混淆并不存在流程分支扁平化(与OLLVM相对比)。结合上述分析也可以看到，所有的混淆执行并不会影响条件标志即CPSR寄存器。
再者，结合堆栈平衡原理，SP寄存器仅仅只需要保存堆栈的变化，比如stmfd仅仅对SP寄存器进行减法操作。
最后，根据上述找到的混淆模式，可以发现使用的指令其实很少，实际编写模拟函数工作量也比较小。
def do_emulate(code, base, Rx):
    ret_addr = 0xffffffff
    emu = ARM_emu()
    md = Cs(CS_ARCH_ARM, CS_MODE_ARM)
    md.detail = True

    for i in md.disasm(code, base):
        emu.regs[PC] = i.address + 2 * inst_size
        dst = i.operands[0]
        src = i.operands[1]

        if (i.mnemonic).upper() == 'LDR':
            if dst.type == ARM_OP_REG and src.type == ARM_OP_MEM:
                Rd = conv_reg(dst.value.reg)    
                Rs = conv_reg(src.value.mem.base)
                addr = emu.regs[Rs] + src.value.mem.disp
                emu.regs[Rd] = Dword(addr & 0xffffffff)

                if Debug:
                    print ('\t LDR %s :\t0x%x' %(i.op_str, emu.regs[Rd]))

        elif (i.mnemonic).upper() == 'ADD':
            if i.operands[0].type == ARM_OP_REG and i.operands[1].type == ARM_OP_REG and i.operands[2].type == ARM_OP_REG:
                Rd = conv_reg(i.operands[0].value.reg)
                R1 = conv_reg(i.operands[1].value.reg)
                R2 = conv_reg(i.operands[2].value.reg)
                emu.regs[Rd] = (emu.regs[R1] + emu.regs[R2]) & 0xffffffff

                if Debug:
                    print ('\t ADD %s :\t0x%x' %(i.op_str, emu.regs[Rd]))
        ...
在模拟执行一条真实指令时，首先将所有寄存器的初始值设置为0，通过主流程中的B指令进入到混淆指令。
3.2 真实指令提取
模拟执行时，将混淆中的每条指令都存储到一个指令堆栈中。结合之前直接字符串模式的思路，来实现对真实指令的提取。
以80A01364为例子来说明真实指令的提取方法。
seg013:80A01364 sub_80A01364                            ; CODE XREF: sub_80A06620 j
seg013:80A01364                 B               sub_80A0663C

seg013:80A0663C                 BMI             loc_80A06648
seg013:80A06640                 BPL             loc_80A06644
seg013:80A06644
seg013:80A06644 loc_80A06644                            ; CODE XREF: sub_80A0663C+4 j
seg013:80A06644                                         ; sub_80A0663C:loc_80A06648 j
seg013:80A06644                 B               loc_80A06624
seg013:80A06648 ; 
seg013:80A06648
seg013:80A06648 loc_80A06648                            ; CODE XREF: sub_80A0663C j
seg013:80A06648                 B               loc_80A06644

seg013:80A06624 loc_80A06624                            ; CODE XREF: 
seg013:80A06624                 MOV             R1, R2
seg013:80A06628                 STMFD           SP!, {R0,LR}
seg013:80A0662C                 MOV             LR, PC
seg013:80A06630                 BL              loc_80A06634
seg013:80A06634 ; 
seg013:80A06634
seg013:80A06634 loc_80A06634                            ; CODE XREF: sub_80A0663C-C j
seg013:80A06634                 LDMFD           SP!, {R0,LR}
seg013:80A06638                 B               sub_80A0664C

seg013:80A0664C sub_80A0664C                            ; CODE XREF: sub_80A0663C-4 p
seg013:80A0664C                 B               sub_80A01368
若不在模拟执行中对指令堆栈修正，那么执行完后存储指令如下所示：
80A0663C    BMI     loc_80A06648
80A06648    B       loc_80A06644
80A06644    B       loc_80A06624
80A06624    MOV     R1, R2
80A06628    STMFD   SP!, {R0,LR}
80A06630    BL      loc_80A06634
80A06634    LDMFD   SP!, {R0,LR}
80A06638    B       sub_80A0664C
80A0664C    B       sub_80A01368
对于BMI，虽然形式上和之前分析的(BEQ loc_80A0658C,BNE loc_80A0658C)直接跳到next_jmp，但检测下一条指令即可根据条件相反去处。
对于STM-LDM，当遇到LDM指令时，将STM-LDM及其之间的指令出栈移除。
剩余(B B MOV B)这些指令，根据上述人工分析的结果可知，因为只存在一条真实指令，那么MOV必定是真实指令。另外，存在这种情况(B B BNE B)，产生这种情况的根本原因是混淆前这条指令是if或者循环语句的判定点，直接取出BNE指令即可。
3.3 函数识别
不管是基于指令名称匹配还是解析执行，都需要对函数进行识别。先来看一个函数混淆片段：
seg013:80A067F0 loc_80A067F0                    ; CODE XREF: seg013:loc_80A06838 j
seg013:80A067F0                 ADR             LR, sub_80A06814
seg013:80A067F4                 STMFD           SP!, {R8,R9,LR}
seg013:80A067F8                 LDR             R8, loc_80A067FC
seg013:80A067FC
seg013:80A067FC loc_80A067FC                            ; DATA XREF: seg013:80A067F8 r
seg013:80A067FC                 LDR             R9, =0x1A6016A4
seg013:80A06800                 ADD             R8, R9, R8
seg013:80A06804                 ADD             R8, PC, R8 ; j_strlen
seg013:80A06808                 STR             R8, [SP,#8]
seg013:80A0680C                 LDMFD           SP!, {R8,R9,PC}
对于未混淆的指令，函数通常被编译为BL或者BLX(指令模式切换)。由于B指令本身的跳转地址范围很有限，那么混淆后代码膨胀必定需要对其指令修正，有点类似InlineHook指令修正。另外，函数的返回地址需要显式存放到LR寄存器。
这样，上述代码在模拟执行时，当LR寄存器值不为0时，将后续的函数调用转化为'Call sub_xxx'指令，将PC置为next_jmp(sub_80A06814)接着模拟。
另外，便于更加清晰的分析，将libc.so加载到和进程一致的基地址，通过IDAPython GetFunctionName获取函数名称。
至此，即可提取出真实指令，check函数流程：
0x80a0135c            PUSH            {r3, r4, r5, r6, r7, r8, sl, lr}
0x80a01360            LDR             r3, [r0]
0x80a01364            MOV             r1, r2
0x80a01368            MOV             r6, r2
0x80a0136c            LDR             r3, [r3, #0x2a4]
0x80a01370            MOV             r2, #0
0x80a01374            MOV             r4, r0
0x80a01378            BLX             r3
0x80a0137c            MOV             r7, r0
0x80a01380            call  j_strlen
0x80a01384            ADD             sl, r0, #1
0x80a01388            MOV             r8, r0
0x80a0138c            MOV             r0, sl
0x80a01390            call  j_malloc_0
0x80a01394            MOV             r1, r7
0x80a01398            MOV             r2, sl
0x80a0139c            MOV             r5, r0
0x80a013a0            call  j_memcpy
0x80a013a4            LDR             r3, [r4]
0x80a013a8            MOV             r2, #0
0x80a013ac            STRB            r2, [r5, r8]
0x80a013b0            LDR             r3, [r3, #0x2a8]
0x80a013b4            MOV             r2, r7
0x80a013b8            MOV             r0, r4
0x80a013bc            MOV             r1, r6
0x80a013c0            BLX             r3
0x80a013c4            LDR             R0, =0x12BC4
0x80a013c8            MOV             r1, #0x80
0x80a013cc            LDR             R0, [PC,R0]
0x80a013d0            call  0x80a01048
0x80a013d4            ADD             r5, r5, r0
0x80a013d8            MOV             r0, r5
0x80a013dc            call  0x80a010c0
0x80a013e0            MOV             r4, r0
0x80a013e4            MOV             r0, r5
0x80a013e8            call  j_free_1
0x80a013ec            MOV             r0, r4
0x80a013f0            POP             {r3, r4, r5, r6, r7, r8, sl, pc}

0x04 算法逆向分析

通过简单分析check即可看到算法的核心流程在0x80a010c0这个函数，而0x80a01048函数的功能是对指令路径上的断点进行检测，和其他平台的反调试思路类似，这里把重点放在0x80a010c0的逆向上。自动化分析得到0x80a010c0函数：
0x80a010c0            PUSH            {r4, r5, r6, r7, r8, sb, sl, lr}
0x80a010c4            LDR             R7, =0x12EB4
0x80a010c8            SUB             sp, sp, #0x308
0x80a010cc            ADD             r6, sp, #4 
0x80a010d0            LDR             R7, [PC,R7]
0x80a010d4            LDR             r3, [r7]
0x80a010d8            MOV             r4, r0
0x80a010dc            MOV             r1, #0
0x80a010e0            MOV             r2, #0x100
0x80a010e4            MOV             r0, r6
0x80a010e8            ADD             r5, sp, #0x104 
0x80a010ec            STR             r3, [sp, #0x304]
0x80a010f0            call  j_memset
0x80a010f4            MOV             r1, #0
0x80a010f8            MOV             r2, #0x100
0x80a010fc            MOV             r0, r5
0x80a01100            call  j_memset
0x80a01104            MOV             r0, r4
0x80a01108            call  j_strlen
0x80a0110c            SUBS            sb, r0, #0
0x80a01110            MOVEQ           r0, sb
0x80a01114            BNE             #0x80a01130
0x80a01118            LDR             r2, [sp, #0x304]
0x80a0111c            LDR             r3, [r7]
0x80a01120            CMP             r2, r3
0x80a01124            BNE             #0x80a01334
0x80a01128            ADD             sp, sp, #0x308
0x80a0112c            POP             {r4, r5, r6, r7, r8, sb, sl, pc}

//获取代码段起始256字节作为key
0x80a011bc            LDR             R0, =0x12DC0   //读取代码段起始地址
0x80a011c0            LDR             LR, =0x66666667
0x80a011c4            MOV             r4, #0
0x80a011c8            LDR             R0, [PC,R0]
0x80a011cc            MOV             r3, r0
0x80a011d0            SMULL           r2, ip, lr, r4
0x80a011d4            ASR             r2, r4, #0x1f
0x80a011d8            LDRB            r1, [r3]
0x80a011dc            RSB             r2, r2, ip, asr #1
0x80a011e0            ADD             r2, r2, r2, lsl #2
0x80a011e4            RSB             r2, r2, r4
0x80a011e8            STRB            r1, [r6, r4]
0x80a011ec            ADD             r4, r4, #1
0x80a011f0            CMP             r4, #0x100
0x80a011f4            ADD             r3, r3, r2
0x80a011f8            BNE             #0x80a011d0

//key变换流程
0x80a01218            MOV             r3, #0
0x80a0121c            MOV             r0, r3
0x80a01220            ADD             r4, r4, #1
0x80a01224            ADD             r6, sp, #0x308
0x80a01228            AND             r4, r4, #0xff
0x80a0122c            ADD             r1, r6, r4
0x80a01230            LDRB            r2, [r1, #-0x304] 
0x80a01234            LDRB            r8, [r5, r3] 
0x80a01238            AND             ip, r3, #7 
0x80a0123c            ADD             r0, r2, r0
0x80a01240            AND             r0, r0, #0xff
0x80a01244            ADD             r6, r6, r0
0x80a01248            LDRB            sl, [r6, #-0x304]
0x80a0124c            ASR             sb, r8, #5
0x80a01250            ORR             r8, sb, r8, lsl #3 
0x80a01254            STRB            sl, [r1, #-0x304] 
0x80a01258            STRB            r2, [r6, #-0x304]
0x80a0125c            LDRB            r6, [r1, #-0x304]
0x80a01260            ADD             sl, sp, #0x308
0x80a01264            RSB             r1, ip, #8 // 8 - [0, 7]
0x80a01268            ADD             r2, r2, r6
0x80a0126c            AND             r2, r2, #0xff
0x80a01270            ADD             r2, sl, r2
0x80a01274            LDRB            r2, [r2, #-0x304]
0x80a01278            EOR             r2, r2, r8
0x80a0127c            AND             r2, r2, #0xff
0x80a01280            LSL             r1, r2, r1 
0x80a01284            ORR             ip, r1, r2, asr ip // 循环左移(8 - i)位
0x80a01288            STRB            ip, [r5, r3] 
0x80a0128c            ADD             r3, r3, #1
0x80a01290            CMP             r3, #0x100
0x80a01294            BNE             #0x80a01220

for(i = 0; i < 0x100; i++){
    left_rotate(right_rotate(mid_code[i], 5) ^ key_stream[i], 8 - (i % 8));
...
限于篇幅，就不在一一分析。其中包括RC4算法。最后得到算法编码主流程：
char gen_mid_code[N];
char key_stream[N];

for(i = 0; i < N; i++){
    gen_mid_code[i] = left_rotate(str[gen_index(i, strlen(str))], 8 - (i % 8));
}
gen_key_stream(ori_key, key_stream);
RC4_encrypt(gen_mid_code, key_stream, final_code);
for(i = 0; i < N; i++){
    if(final_code[i] != check_code[i]){
            ...
    }
}
最后，得到flag:Hello Tomorrow!
至此，此ctf题目大致分析完毕。
题目下载地址：http://pan.baidu.com/s/1hrqZH9E
标签：

Popular posts from 产品随想的博客

BIM江湖演义——ArchiCAD vs Revit

原文 地址 江湖中历来不缺乏传奇。在建筑软件的这片江湖中，风云变幻，豪杰辈出，有两大世家始终屹立不倒——一个来自欧罗巴，名字低调：“图形软件”（Graphisoft），却继承了一身的艺术家气质，手握长剑白衣胜雪；一个来自美利坚，人称“自动桌子”（Autodesk），性格豪放不羁，七种武器样样精通。本文所说的，就是这两大世家的代表人物：ArchiCAD与Revit之间的较量。 这个论题本是老生常谈了，谈到BIM绕不过的就是Revit与ArchiCAD。两者的对比许多帖子都讨论过，但往往大而化之，原则性的东西多，细节的东西少，因此我想再作一次比较，希望能深入一点，具体一点，力争较为全面地反映两者的真实面貌。但这种对比往往两面都不讨好，你懂的，因此本文也多用戏说的语气，我姑妄说之，列位看官也就姑妄听之吧，有不当之处还请多多包涵！ 先介绍一下本人对这两个软件的熟悉程度。我用ArchiCAD有4年了，出过几套施工图，都已竣工，编过一系列向日葵图库，颇受好评，对ArchiCAD的认识偏重于施工图；用Revit一年半，出过四个工程的土建及MEP模型，也用其API编了若干插件，对Revit的认识偏重于建模（包括结构及MEP建模）。应该说对ArchiCAD与Revit的认识都算深入了。 当然两者的深度比较是一个庞大的工程，而且个人看法难免有偏见，技术上也多有误解之处，因此希望各位能指正与补充。 1 软件的思想、架构对比 从软件的历史来说，无疑是ArchiCAD悠久得多，Revit是Autodesk在2002年才收购回来的，但Revit有一个强有力的东家，马上推出“BIM”这个很炫的口号，一下把ArchiCAD沿用多年的“虚拟建筑”这个老老实实的口号给打败了，于是ArchiCAD也只好宣称自己是个BIM软件，搞得在外人看来，倒像是Revit占了先机。 从软件设计的角度来看，两者也是差别巨大的。ArchiCAD从20多年前就致力于三维建筑设计，在这方面积累了足够多的经验，多年来也是沿用其架构做一些小更新、小完善、小整合。从我接触的7.0到最新的14.0，感觉比较大的变动就是10.0版整合PlotMaker、12版支持多核计算提升速度、12版新增幕墙工具、13版团队工作大幅改进。在界面上、使用习惯上一直差别不大，这也在一个侧面反映了ArchiCAD软件设计的一个“精英思路”——我本来就...
阅读全文

产品随想 | 周刊 第128期：将时间转化为知识和体验

自行车棚效应：我们为什么在小事上纠结，却对大事视而不见？   https://limboy.me/posts/bike-shedding Benz-Patent   https://www.mercedes-benz.com/en/innovation/milestones/benz-patent-motor-car/ 豐田博物館   https://toyota-automobile-museum.jp/tw/ 值得一去的汽车博物馆 一人公司   https://github.com/cyfyifanchen/one-person-company one-person-company, 一人公司 AI 工具系列 wujiaxian   https://wujiaxian.com/ 可能吧创始人的个人Blog，介绍自己的方式，很值得学习 日本京都10大設計熱點！「建築大師貝聿銘操刀美術館，皆川明設計旅館、選物店，還有全球最美的藍瓶咖啡店舖！」   https://www.elle.com/tw/life/style/g33846398/2020-kyoto-10-hotspots/ 京都真是非常美 Henry L. Stimson   https://en.wikipedia.org/wiki/Henry_L._Stimson?useskin=vector While Kyoto may have satisfied the military criteria for a useful target, Stimson objected, declaring in a meeting if the Interim Committee on June 1, 1945, "...there was one city that they must not bomb without my permission and that was Kyoto." 人性的努力保护了京都 Brooke Astor, 105, Aristocrat of the People, Dies   https://www.nytimes.com/2007/08/14/obituaries/14astor.html 值得尊敬...
阅读全文

产品随想 | 周刊 第52期：HP家的Linux笔记本

Products 腾讯柠檬清理   https://github.com/Tencent/lemon-cleaner 腾讯开源，那基本意味着不再维护了...... (据专业人士看，代码写的烂) Teclis   https://teclis.com/ 一个比较窄，但质量非常高的搜索引擎 Ina La Revue Des Médias   https://larevuedesmedias.ina.fr/ 挺小众的法语网站，对于媒体，对于新闻热点的解读，还挺好 Dashy   https://github.com/Lissy93/dashy A self-hostable personal dashboard built for you. Includes status-checking, widgets, themes, icon packs, a UI editor and tons more! 全定制化的看板，非常酷 OpenSnitch   https://github.com/evilsocket/opensnitch OpenSnitch is a GNU/Linux port of the Little Snitch application firewall 好用的Linux网络状态监控软件，帮助盯住不老实的App 这个工具的创作者，Simone Margaritelli，evilsocket，非常高产 emoji-supply   https://github.com/alcor/emoji-supply 把 Emoji 组合成漂亮的壁纸、封面图 Vue Color Avatar   https://github.com/Codennnn/vue-color-avatar 一个纯前端实现的头像生成网站 itty.bitty   https://github.com/alcor/itty-bitty Itty.bitty is a tool to create links that contain small sites Administrative-divisions-of-China   https://github.com/modood/Administrativ...
阅读全文

内网域名访问内网服务器

部门ftp服务器和远程服务器内网域名无法访问问题困扰我好久，钻研了几天，终于明白了一些，和大家做一个分享， 原帖子在这里 ，表示感谢
阅读全文

路由器与交换机区别

交换机和路由器的区别： 1.路由器可以给局域网自动分配IP，虚拟拨号，交换机只是用来分配网络数据的。 2.路由器在网络层，根据IP地址寻址，可以处理TCP/IP协议，交换机不可以。
阅读全文

分布式系统领域的经典论文【转载】

作者：严林  编辑于 2015-05-08 链接：https://www.zhihu.com/question/30026369/answer/46476717 来源：知乎 著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。 分布式系统在互联网时代，尤其是大数据时代到来之后，成为了每个程序员的必备技能之一。分布式系统从上个世纪80年代就开始有了不少出色的研究和论文，我在这里只列举最近15年范围以内我觉得有重大影响意义的15篇论文（15 within 15）。 1. The Google File System: 这是分布式文件系统领域划时代意义的论文，文中的多副本机制、控制流与数据流隔离和追加写模式等概念几乎成为了分布式文件系统领域的标准，其影响之深远通过其5000+的引用就可见一斑了，Apache Hadoop鼎鼎大名的HDFS就是GFS的模仿之作； 2. MapReduce: Simplified Data Processing on Large Clusters： 这篇也是Google的大作，通过Map和Reduce两个操作，大大简化了分布式计算的复杂度，使得任何需要的程序员都可以编写分布式计算程序，其中使用到的技术值得我们好好学习：简约而不简单！Hadoop也根据这篇论文做了一个开源的MapReduce； 3. Bigtable: A Distributed Storage System for Structured Data： Google在NoSQL领域的分布式表格系统，LSM树的最好使用范例，广泛使用到了网页索引存储、YouTube数据管理等业务，Hadoop对应的开源系统叫HBase（我在前公司任职时也开发过一个相应的系统叫BladeCube，性能较HBase有数倍提升）； 4. The Chubby lock service for loosely-coupled distributed systems： Google的分布式锁服务，基于Paxos协议，这篇文章相比于前三篇可能知道的人就少了，但是其对应的开源系统zookeeper几乎是每个后端同学都接触过，其影响力其实不亚于前三篇； 5. Finding a Needle in Haystack: Facebook's Photo Storage： ...
阅读全文

李录推荐阅读书单

李录推荐阅读书单 李录在《文明、现代化、价值投资和中国》的最后，列出了他推荐阅读的一些书目。这个书目的含金量非常之高，是培养一个多层次有深度思维很好的参考，特整理如下。 一. 科学、哲学、进化、人类文明史、人类历史 1. 《枪炮、病菌与钢铁：人类社会的命运》，贾雷德·戴蒙德 2. 《西方将主宰多久》，伊恩·莫里斯 3. 《文明的度量：社会发展如何决定国家命运》，伊恩·莫里斯 4. 《群的征服》，爱德华·奥斯本·威尔森 5. 《无穷的开始：世界进步的本源》，戴维·多伊奇 6. 《真实世界的脉络：平行宇宙及其寓意》，戴维·多伊奇 7. 《理性乐观派：一部人类经济进步史》，马特·里德利 8. 《科学发现的逻辑》，卡尔·波普尔 9. 《开放社会及其敌人》，卡尔·波普尔 10. 《自私的基因》，理查德·道金斯 11. 《人类简史：从动物到上帝》，尤瓦尔·赫拉利 12. 《文明》，尼尔·弗格森 13. 《当下的启蒙》，史蒂芬·平克 14. 《心智探奇：人类心智的起源与进化》，史蒂芬·平克 15. A history of knowledge, Charles Van Doren 16. 《神的历史》，凯伦·阿姆斯特朗 17. 《为什么佛学是真实的》，罗伯特·赖特 18. 《思考，快与慢》，丹尼尔·卡尼曼 19. Creating the Twentieth Century, Vaclav Smil 20. Transforming the Twentieth Century, Vaclav Smil 二. 中国文明、历史、文化 1. 《先秦诸子系年》，钱穆 2. 《中华文化十二讲》，钱穆 3. 《史记（白话本）》，司马迁 4. 《白话二十五史精选》，李解民等 5. 《四书章句集注》，朱熹 6. Waiting for the Dawn, William Theodore de Bary 7. 《中国的自由传统》，狄百瑞 8. 《万古江河——中国历史文化的转折和开展》，许倬云 9. 《黄宗羲全集》 10. 《余英时文集》 11. 《思想和人物》，林毓生 12. 《曾国藩全集》 13. 《万历十五年》，黄仁宇 14. 《天安门：知识分子与中国革命》，史景迁 15. The Search for Modern China, 史景迁 16. 《中国官僚政治研究》，王亚南 17. 《中...
阅读全文

产品随想 | 周刊 第130期：集结信徒，而非官僚

On Dyson, techno-centric design and social consumption   https://2earth.github.io/website/20250707.html 如何創造偉大的事物   https://ryolu.notion.site/1610a94b9c108079a95be4362afd4a26 集結信徒，而非官僚 Reflections on OpenAI   https://calv.info/openai-reflections 创业架构 Shui   https://github.com/rock-zhang/Shui 好好喝水 https://www.ghibli.jp/works/ 吉卜力作品的高清图 From Skeuomorphic to Liquid Glass: Apple's Strategic Bet on the Post-Touch Future   https://omc345.substack.com/p/from-skeuomorphic-to-liquid-glass 迄今为止关于苹果Liquid Glass变革的解读，最好的一篇 The Nueva School   https://en.wikipedia.org/wiki/The_Nueva_School?useskin=vector 看起来是很酷的一个学校 The Barbican   https://arslan.io/2025/05/12/barbican-estate/ 史蒂夫·乔布斯希望你阅读的 9 本书   https://www.douban.com/doulist/147158849/ 《禅者的初心》里有句话：“做任何事，其实都是在展示内心的天性，这是我们存在的唯一理由。” Chuck Feeney was one of the greatest philanthropists ever   https://www.gatesnotes.com/Remembering-Chuck-Feeney 慈善家 My new deadline: 20 years to give away virtually all my wealt...
阅读全文

《Becoming Steve Jobs》Chapter 13 Stanford

Steve was a natural performer who elevated business presentations to something close to high art. But what made him fidgety this day was the prospect of addressing the Stanford University graduating class of 2005. University president John Hennessy had broached the idea several months earlier, and after taking just a little time to think it over, Steve had said yes. He was offered speaking engagements constantly, and he always said no. In fact, he was asked to do so many commencement addresses that it became a running joke with Laurene and other friends who had college or graduate degrees: Steve said he’d accept one just to make an end run around them and get his PhD in a day, versus the years and years it had taken them. But in the end, saying no was simply a question of return on investment—conferences and public speaking seemed to offer a meager payoff compared to other things, like a dazzling MacWorld presentation, working on a great product, or being around his family. “If you loo...
阅读全文

写给大家看的中文排版指南

作者：Hindy 原文地址： http:// zhuanlan.zhihu.com/uici rcle/20506092 前言：很遗憾，我们的周围充斥着大量排版丑陋的文章。我国的字体排印与日本、美国等设计强国差距实在太大。我希望能够做些力所能及的小事，让更多人意识到“设计”的价值和其必要性，创造更美好的视觉环境。本文旨在帮助普及、提升大家对文字排版的认识，让大家在平时的学习工作中能有更专业的文字排版素养。 必看人群： 设计师、编辑、作家、撰稿人、教师、学生 目录： 1. 中文排版 1.1 引号 1.2 省略号与破折号 1.3 行首行尾禁则 2. 西文排版基础 2.1 西文撰写基础 2.2 西文标点相关 2.3 斜体的用法 2.4 大小写的区别 3. 中西文混排 3.1 基础原则 3.2 标点相关 1. 中文排版 1.1 引号 我国国家标准要求弯引号，个人建议使用直角引号。 示例：你竟然喜欢“苹果表”？ 引号中再用引号使用双直角引号。 示例：我问他，“你竟然喜欢‘苹果表’？” 当引号表示讽刺、反语暗示时，使用弯引号（用法参考“西文排版”部分）。 示例：说真的，我也很 “喜欢”“苹果表”哦。 1.2 省略号（删节号）与破折号 省略号占两个汉字空间，包含六个点。 正确示例：中国设计还有太长路要走…… 错误示例：中国设计还有太长路要走… 破折号占两个汉字空间。 示例：中国设计还有太长路要走──加油罢。 1.3 行首行尾禁则 点号（顿号、逗号、句号等）、结束引号、结束括号等，不能出现在一行的开头。 错误示例： 排版时注意某些 符号不能在行首 ，别弄错了。 正确示例： 排版时注意某些 符号不能在行首， 别弄错了。 开始引号、开始括号、开始双书名号等，不能出现在一行的结尾。 错误示例： 她对我们说：“ 这书太赞了。” 正确示例： 她对我们说： “这书太赞了。” 2. 西文排版基础 2.1 西文撰写基础 句首字母大写。 单词间留空格。 示例：Have a question? 2.2 西文标点相关 点号后加一个空格（如逗号、句号等）。 示例：Hello everyone! Welcome to my blog....
阅读全文